Uranium-and-Waffles/Dec2017-Script-Dump
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scripts

Browse Source
This commit is contained in:
niko
2026-06-04 11:42:34 +02:00
parent f39ba70a9f
commit e720b98cd1
7488 changed files with 2493818 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
UnityEngine/GUI.cs
+2231
View File
@@ -0,0 +1,2231 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Scripting;
using UnityEngineInternal;
namespace UnityEngine
{
// Token: 0x02000258 RID: 600
public class GUI
{
// Token: 0x170009A1 RID: 2465
// (get) Token: 0x060028B5 RID: 10421 RVA: 0x0002FAE8 File Offset: 0x0002DCE8
// (set) Token: 0x060028B6 RID: 10422 RVA: 0x0002FB04 File Offset: 0x0002DD04
internal static int scrollTroughSide { get; set; }
// Token: 0x170009A2 RID: 2466
// (get) Token: 0x060028B7 RID: 10423 RVA: 0x0002FB0C File Offset: 0x0002DD0C
// (set) Token: 0x060028B8 RID: 10424 RVA: 0x0002FB28 File Offset: 0x0002DD28
internal static DateTime nextScrollStepTime { get; set; } = DateTime.Now;
// Token: 0x170009A3 RID: 2467
// (get) Token: 0x060028BA RID: 10426 RVA: 0x0002FB40 File Offset: 0x0002DD40
// (set) Token: 0x060028B9 RID: 10425 RVA: 0x0002FB30 File Offset: 0x0002DD30
public static GUISkin skin
{
get
{
GUIUtility.CheckOnGUI();
return GUI.s_Skin;
}
set
{
GUIUtility.CheckOnGUI();
GUI.DoSetSkin(value);
}
}
// Token: 0x060028BB RID: 10427 RVA: 0x0002FB60 File Offset: 0x0002DD60
internal static void DoSetSkin(GUISkin newSkin)
{
if (!newSkin)
{
newSkin = GUIUtility.GetDefaultSkin();
}
GUI.s_Skin = newSkin;
newSkin.MakeCurrent();
}
// Token: 0x060028BC RID: 10428 RVA: 0x0002FB84 File Offset: 0x0002DD84
internal static void CleanupRoots()
{
GUI.s_Skin = null;
GUIUtility.CleanupRoots();
GUILayoutUtility.CleanupRoots();
GUISkin.CleanupRoots();
GUIStyle.CleanupRoots();
}
// Token: 0x170009A4 RID: 2468
// (get) Token: 0x060028BD RID: 10429 RVA: 0x0002FBA4 File Offset: 0x0002DDA4
// (set) Token: 0x060028BE RID: 10430 RVA: 0x0002FBC0 File Offset: 0x0002DDC0
public static Matrix4x4 matrix
{
get
{
return GUIClip.GetMatrix();
}
set
{
GUIClip.SetMatrix(value);
}
}
// Token: 0x170009A5 RID: 2469
// (get) Token: 0x060028BF RID: 10431 RVA: 0x0002FBCC File Offset: 0x0002DDCC
// (set) Token: 0x060028C0 RID: 10432 RVA: 0x0002FBFC File Offset: 0x0002DDFC
public static string tooltip
{
get
{
string text = GUI.Internal_GetTooltip();
string text2;
if (text != null)
{
text2 = text;
}
else
{
text2 = "";
}
return text2;
}
set
{
GUI.Internal_SetTooltip(value);
}
}
// Token: 0x170009A6 RID: 2470
// (get) Token: 0x060028C1 RID: 10433 RVA: 0x0002FC08 File Offset: 0x0002DE08
protected static string mouseTooltip
{
get
{
return GUI.Internal_GetMouseTooltip();
}
}
// Token: 0x170009A7 RID: 2471
// (get) Token: 0x060028C2 RID: 10434 RVA: 0x0002FC24 File Offset: 0x0002DE24
// (set) Token: 0x060028C3 RID: 10435 RVA: 0x0002FC40 File Offset: 0x0002DE40
protected static Rect tooltipRect
{
get
{
return GUI.s_ToolTipRect;
}
set
{
GUI.s_ToolTipRect = value;
}
}
// Token: 0x060028C4 RID: 10436 RVA: 0x0002FC4C File Offset: 0x0002DE4C
public static void Label(Rect position, string text)
{
GUI.Label(position, GUIContent.Temp(text), GUI.s_Skin.label);
}
// Token: 0x060028C5 RID: 10437 RVA: 0x0002FC68 File Offset: 0x0002DE68
public static void Label(Rect position, Texture image)
{
GUI.Label(position, GUIContent.Temp(image), GUI.s_Skin.label);
}
// Token: 0x060028C6 RID: 10438 RVA: 0x0002FC84 File Offset: 0x0002DE84
public static void Label(Rect position, GUIContent content)
{
GUI.Label(position, content, GUI.s_Skin.label);
}
// Token: 0x060028C7 RID: 10439 RVA: 0x0002FC98 File Offset: 0x0002DE98
public static void Label(Rect position, string text, GUIStyle style)
{
GUI.Label(position, GUIContent.Temp(text), style);
}
// Token: 0x060028C8 RID: 10440 RVA: 0x0002FCA8 File Offset: 0x0002DEA8
public static void Label(Rect position, Texture image, GUIStyle style)
{
GUI.Label(position, GUIContent.Temp(image), style);
}
// Token: 0x060028C9 RID: 10441 RVA: 0x0002FCB8 File Offset: 0x0002DEB8
public static void Label(Rect position, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
GUI.DoLabel(position, content, style.m_Ptr);
}
// Token: 0x060028CA RID: 10442 RVA: 0x0002FCD0 File Offset: 0x0002DED0
public static void DrawTexture(Rect position, Texture image)
{
GUI.DrawTexture(position, image, ScaleMode.StretchToFill);
}
// Token: 0x060028CB RID: 10443 RVA: 0x0002FCDC File Offset: 0x0002DEDC
public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode)
{
GUI.DrawTexture(position, image, scaleMode, true);
}
// Token: 0x060028CC RID: 10444 RVA: 0x0002FCE8 File Offset: 0x0002DEE8
public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode, bool alphaBlend)
{
GUI.DrawTexture(position, image, scaleMode, alphaBlend, 0f);
}
// Token: 0x060028CD RID: 10445 RVA: 0x0002FCFC File Offset: 0x0002DEFC
public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode, bool alphaBlend, float imageAspect)
{
GUI.DrawTexture(position, image, scaleMode, alphaBlend, imageAspect, GUI.color, 0f, 0f);
}
// Token: 0x060028CE RID: 10446 RVA: 0x0002FD1C File Offset: 0x0002DF1C
public static void DrawTexture(Rect position, Texture image, ScaleMode scaleMode, bool alphaBlend, float imageAspect, Color color, float borderWidth, float cornerRadius)
{
GUIUtility.CheckOnGUI();
if (Event.current.type == EventType.Repaint)
{
if (image == null)
{
Debug.LogWarning("null texture passed to GUI.DrawTexture");
}
else
{
if (imageAspect == 0f)
{
imageAspect = (float)image.width / (float)image.height;
}
Material material;
if (borderWidth > Mathf.Epsilon || cornerRadius > Mathf.Epsilon)
{
material = GUI.roundedRectMaterial;
}
else
{
material = ((!alphaBlend) ? GUI.blitMaterial : GUI.blendMaterial);
}
Internal_DrawTextureArguments internal_DrawTextureArguments = default(Internal_DrawTextureArguments);
internal_DrawTextureArguments.leftBorder = 0;
internal_DrawTextureArguments.rightBorder = 0;
internal_DrawTextureArguments.topBorder = 0;
internal_DrawTextureArguments.bottomBorder = 0;
internal_DrawTextureArguments.color = color;
internal_DrawTextureArguments.borderWidth = borderWidth;
internal_DrawTextureArguments.cornerRadius = cornerRadius;
internal_DrawTextureArguments.texture = image;
internal_DrawTextureArguments.mat = material;
GUI.CalculateScaledTextureRects(position, scaleMode, imageAspect, ref internal_DrawTextureArguments.screenRect, ref internal_DrawTextureArguments.sourceRect);
Graphics.Internal_DrawTexture(ref internal_DrawTextureArguments);
}
}
}
// Token: 0x060028CF RID: 10447 RVA: 0x0002FE2C File Offset: 0x0002E02C
internal static bool CalculateScaledTextureRects(Rect position, ScaleMode scaleMode, float imageAspect, ref Rect outScreenRect, ref Rect outSourceRect)
{
float num = position.width / position.height;
bool flag = false;
if (scaleMode != ScaleMode.StretchToFill)
{
if (scaleMode != ScaleMode.ScaleAndCrop)
{
if (scaleMode == ScaleMode.ScaleToFit)
{
if (num > imageAspect)
{
float num2 = imageAspect / num;
outScreenRect = new Rect(position.xMin + position.width * (1f - num2) * 0.5f, position.yMin, num2 * position.width, position.height);
outSourceRect = new Rect(0f, 0f, 1f, 1f);
flag = true;
}
else
{
float num3 = num / imageAspect;
outScreenRect = new Rect(position.xMin, position.yMin + position.height * (1f - num3) * 0.5f, position.width, num3 * position.height);
outSourceRect = new Rect(0f, 0f, 1f, 1f);
flag = true;
}
}
}
else if (num > imageAspect)
{
float num4 = imageAspect / num;
outScreenRect = position;
outSourceRect = new Rect(0f, (1f - num4) * 0.5f, 1f, num4);
flag = true;
}
else
{
float num5 = num / imageAspect;
outScreenRect = position;
outSourceRect = new Rect(0.5f - num5 * 0.5f, 0f, num5, 1f);
flag = true;
}
}
else
{
outScreenRect = position;
outSourceRect = new Rect(0f, 0f, 1f, 1f);
flag = true;
}
return flag;
}
// Token: 0x060028D0 RID: 10448 RVA: 0x0002FFD8 File Offset: 0x0002E1D8
public static void DrawTextureWithTexCoords(Rect position, Texture image, Rect texCoords)
{
GUI.DrawTextureWithTexCoords(position, image, texCoords, true);
}
// Token: 0x060028D1 RID: 10449 RVA: 0x0002FFE4 File Offset: 0x0002E1E4
public static void DrawTextureWithTexCoords(Rect position, Texture image, Rect texCoords, bool alphaBlend)
{
GUIUtility.CheckOnGUI();
if (Event.current.type == EventType.Repaint)
{
Material material = ((!alphaBlend) ? GUI.blitMaterial : GUI.blendMaterial);
Internal_DrawTextureArguments internal_DrawTextureArguments = default(Internal_DrawTextureArguments);
internal_DrawTextureArguments.texture = image;
internal_DrawTextureArguments.mat = material;
internal_DrawTextureArguments.leftBorder = 0;
internal_DrawTextureArguments.rightBorder = 0;
internal_DrawTextureArguments.topBorder = 0;
internal_DrawTextureArguments.bottomBorder = 0;
internal_DrawTextureArguments.color = GUI.color;
internal_DrawTextureArguments.screenRect = position;
internal_DrawTextureArguments.sourceRect = texCoords;
Graphics.Internal_DrawTexture(ref internal_DrawTextureArguments);
}
}
// Token: 0x060028D2 RID: 10450 RVA: 0x00030080 File Offset: 0x0002E280
public static void Box(Rect position, string text)
{
GUI.Box(position, GUIContent.Temp(text), GUI.s_Skin.box);
}
// Token: 0x060028D3 RID: 10451 RVA: 0x0003009C File Offset: 0x0002E29C
public static void Box(Rect position, Texture image)
{
GUI.Box(position, GUIContent.Temp(image), GUI.s_Skin.box);
}
// Token: 0x060028D4 RID: 10452 RVA: 0x000300B8 File Offset: 0x0002E2B8
public static void Box(Rect position, GUIContent content)
{
GUI.Box(position, content, GUI.s_Skin.box);
}
// Token: 0x060028D5 RID: 10453 RVA: 0x000300CC File Offset: 0x0002E2CC
public static void Box(Rect position, string text, GUIStyle style)
{
GUI.Box(position, GUIContent.Temp(text), style);
}
// Token: 0x060028D6 RID: 10454 RVA: 0x000300DC File Offset: 0x0002E2DC
public static void Box(Rect position, Texture image, GUIStyle style)
{
GUI.Box(position, GUIContent.Temp(image), style);
}
// Token: 0x060028D7 RID: 10455 RVA: 0x000300EC File Offset: 0x0002E2EC
public static void Box(Rect position, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
int controlID = GUIUtility.GetControlID(GUI.s_BoxHash, FocusType.Passive);
if (Event.current.type == EventType.Repaint)
{
style.Draw(position, content, controlID);
}
}
// Token: 0x060028D8 RID: 10456 RVA: 0x00030128 File Offset: 0x0002E328
public static bool Button(Rect position, string text)
{
return GUI.Button(position, GUIContent.Temp(text), GUI.s_Skin.button);
}
// Token: 0x060028D9 RID: 10457 RVA: 0x00030154 File Offset: 0x0002E354
public static bool Button(Rect position, Texture image)
{
return GUI.Button(position, GUIContent.Temp(image), GUI.s_Skin.button);
}
// Token: 0x060028DA RID: 10458 RVA: 0x00030180 File Offset: 0x0002E380
public static bool Button(Rect position, GUIContent content)
{
return GUI.Button(position, content, GUI.s_Skin.button);
}
// Token: 0x060028DB RID: 10459 RVA: 0x000301A8 File Offset: 0x0002E3A8
public static bool Button(Rect position, string text, GUIStyle style)
{
return GUI.Button(position, GUIContent.Temp(text), style);
}
// Token: 0x060028DC RID: 10460 RVA: 0x000301CC File Offset: 0x0002E3CC
public static bool Button(Rect position, Texture image, GUIStyle style)
{
return GUI.Button(position, GUIContent.Temp(image), style);
}
// Token: 0x060028DD RID: 10461 RVA: 0x000301F0 File Offset: 0x0002E3F0
public static bool Button(Rect position, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoButton(position, content, style.m_Ptr);
}
// Token: 0x060028DE RID: 10462 RVA: 0x00030218 File Offset: 0x0002E418
public static bool RepeatButton(Rect position, string text)
{
return GUI.DoRepeatButton(position, GUIContent.Temp(text), GUI.s_Skin.button, FocusType.Passive);
}
// Token: 0x060028DF RID: 10463 RVA: 0x00030244 File Offset: 0x0002E444
public static bool RepeatButton(Rect position, Texture image)
{
return GUI.DoRepeatButton(position, GUIContent.Temp(image), GUI.s_Skin.button, FocusType.Passive);
}
// Token: 0x060028E0 RID: 10464 RVA: 0x00030270 File Offset: 0x0002E470
public static bool RepeatButton(Rect position, GUIContent content)
{
return GUI.DoRepeatButton(position, content, GUI.s_Skin.button, FocusType.Passive);
}
// Token: 0x060028E1 RID: 10465 RVA: 0x00030298 File Offset: 0x0002E498
public static bool RepeatButton(Rect position, string text, GUIStyle style)
{
return GUI.DoRepeatButton(position, GUIContent.Temp(text), style, FocusType.Passive);
}
// Token: 0x060028E2 RID: 10466 RVA: 0x000302BC File Offset: 0x0002E4BC
public static bool RepeatButton(Rect position, Texture image, GUIStyle style)
{
return GUI.DoRepeatButton(position, GUIContent.Temp(image), style, FocusType.Passive);
}
// Token: 0x060028E3 RID: 10467 RVA: 0x000302E0 File Offset: 0x0002E4E0
public static bool RepeatButton(Rect position, GUIContent content, GUIStyle style)
{
return GUI.DoRepeatButton(position, content, style, FocusType.Passive);
}
// Token: 0x060028E4 RID: 10468 RVA: 0x00030300 File Offset: 0x0002E500
private static bool DoRepeatButton(Rect position, GUIContent content, GUIStyle style, FocusType focusType)
{
GUIUtility.CheckOnGUI();
int controlID = GUIUtility.GetControlID(GUI.s_RepeatButtonHash, focusType, position);
EventType typeForControl = Event.current.GetTypeForControl(controlID);
bool flag;
if (typeForControl != EventType.MouseDown)
{
if (typeForControl != EventType.MouseUp)
{
if (typeForControl != EventType.Repaint)
{
flag = false;
}
else
{
style.Draw(position, content, controlID);
flag = controlID == GUIUtility.hotControl && position.Contains(Event.current.mousePosition);
}
}
else if (GUIUtility.hotControl == controlID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
flag = position.Contains(Event.current.mousePosition);
}
else
{
flag = false;
}
}
else
{
if (position.Contains(Event.current.mousePosition))
{
GUIUtility.hotControl = controlID;
Event.current.Use();
}
flag = false;
}
return flag;
}
// Token: 0x060028E5 RID: 10469 RVA: 0x000303E4 File Offset: 0x0002E5E4
public static string TextField(Rect position, string text)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, -1, GUI.skin.textField);
return guicontent.text;
}
// Token: 0x060028E6 RID: 10470 RVA: 0x00030420 File Offset: 0x0002E620
public static string TextField(Rect position, string text, int maxLength)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, maxLength, GUI.skin.textField);
return guicontent.text;
}
// Token: 0x060028E7 RID: 10471 RVA: 0x0003045C File Offset: 0x0002E65C
public static string TextField(Rect position, string text, GUIStyle style)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, -1, style);
return guicontent.text;
}
// Token: 0x060028E8 RID: 10472 RVA: 0x00030490 File Offset: 0x0002E690
public static string TextField(Rect position, string text, int maxLength, GUIStyle style)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, maxLength, style);
return guicontent.text;
}
// Token: 0x060028E9 RID: 10473 RVA: 0x000304C4 File Offset: 0x0002E6C4
public static string PasswordField(Rect position, string password, char maskChar)
{
return GUI.PasswordField(position, password, maskChar, -1, GUI.skin.textField);
}
// Token: 0x060028EA RID: 10474 RVA: 0x000304EC File Offset: 0x0002E6EC
public static string PasswordField(Rect position, string password, char maskChar, int maxLength)
{
return GUI.PasswordField(position, password, maskChar, maxLength, GUI.skin.textField);
}
// Token: 0x060028EB RID: 10475 RVA: 0x00030514 File Offset: 0x0002E714
public static string PasswordField(Rect position, string password, char maskChar, GUIStyle style)
{
return GUI.PasswordField(position, password, maskChar, -1, style);
}
// Token: 0x060028EC RID: 10476 RVA: 0x00030534 File Offset: 0x0002E734
public static string PasswordField(Rect position, string password, char maskChar, int maxLength, GUIStyle style)
{
GUIUtility.CheckOnGUI();
string text = GUI.PasswordFieldGetStrToShow(password, maskChar);
GUIContent guicontent = GUIContent.Temp(text);
bool changed = GUI.changed;
GUI.changed = false;
if (TouchScreenKeyboard.isSupported)
{
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard), guicontent, false, maxLength, style, password, maskChar);
}
else
{
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, maxLength, style);
}
text = ((!GUI.changed) ? password : guicontent.text);
GUI.changed = GUI.changed || changed;
return text;
}
// Token: 0x060028ED RID: 10477 RVA: 0x000305C4 File Offset: 0x0002E7C4
internal static string PasswordFieldGetStrToShow(string password, char maskChar)
{
return (Event.current.type != EventType.Repaint && Event.current.type != EventType.MouseDown) ? password : "".PadRight(password.Length, maskChar);
}
// Token: 0x060028EE RID: 10478 RVA: 0x00030610 File Offset: 0x0002E810
public static string TextArea(Rect position, string text)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, true, -1, GUI.skin.textArea);
return guicontent.text;
}
// Token: 0x060028EF RID: 10479 RVA: 0x0003064C File Offset: 0x0002E84C
public static string TextArea(Rect position, string text, int maxLength)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, true, maxLength, GUI.skin.textArea);
return guicontent.text;
}
// Token: 0x060028F0 RID: 10480 RVA: 0x00030688 File Offset: 0x0002E888
public static string TextArea(Rect position, string text, GUIStyle style)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, true, -1, style);
return guicontent.text;
}
// Token: 0x060028F1 RID: 10481 RVA: 0x000306BC File Offset: 0x0002E8BC
public static string TextArea(Rect position, string text, int maxLength, GUIStyle style)
{
GUIContent guicontent = GUIContent.Temp(text);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, maxLength, style);
return guicontent.text;
}
// Token: 0x060028F2 RID: 10482 RVA: 0x000306F0 File Offset: 0x0002E8F0
private static string TextArea(Rect position, GUIContent content, int maxLength, GUIStyle style)
{
GUIContent guicontent = GUIContent.Temp(content.text, content.image);
GUI.DoTextField(position, GUIUtility.GetControlID(FocusType.Keyboard, position), guicontent, false, maxLength, style);
return guicontent.text;
}
// Token: 0x060028F3 RID: 10483 RVA: 0x00030730 File Offset: 0x0002E930
internal static void DoTextField(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style)
{
GUI.DoTextField(position, id, content, multiline, maxLength, style, null);
}
// Token: 0x060028F4 RID: 10484 RVA: 0x00030744 File Offset: 0x0002E944
internal static void DoTextField(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style, string secureText)
{
GUI.DoTextField(position, id, content, multiline, maxLength, style, secureText, '\0');
}
// Token: 0x060028F5 RID: 10485 RVA: 0x00030758 File Offset: 0x0002E958
internal static void DoTextField(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style, string secureText, char maskChar)
{
GUIUtility.CheckOnGUI();
if (maxLength >= 0 && content.text.Length > maxLength)
{
content.text = content.text.Substring(0, maxLength);
}
TextEditor textEditor = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), id);
textEditor.text = content.text;
textEditor.SaveBackup();
textEditor.position = position;
textEditor.style = style;
textEditor.multiline = multiline;
textEditor.controlID = id;
textEditor.DetectFocusChange();
if (TouchScreenKeyboard.isSupported)
{
GUI.HandleTextFieldEventForTouchscreen(position, id, content, multiline, maxLength, style, secureText, maskChar, textEditor);
}
else
{
GUI.HandleTextFieldEventForDesktop(position, id, content, multiline, maxLength, style, textEditor);
}
textEditor.UpdateScrollOffsetIfNeeded(Event.current);
}
// Token: 0x060028F6 RID: 10486 RVA: 0x00030824 File Offset: 0x0002EA24
private static void HandleTextFieldEventForTouchscreen(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style, string secureText, char maskChar, TextEditor editor)
{
Event current = Event.current;
EventType type = current.type;
if (type != EventType.MouseDown)
{
if (type == EventType.Repaint)
{
if (editor.keyboardOnScreen != null)
{
content.text = editor.keyboardOnScreen.text;
if (maxLength >= 0 && content.text.Length > maxLength)
{
content.text = content.text.Substring(0, maxLength);
}
if (editor.keyboardOnScreen.done)
{
editor.keyboardOnScreen = null;
GUI.changed = true;
}
}
string text = content.text;
if (secureText != null)
{
content.text = GUI.PasswordFieldGetStrToShow(text, maskChar);
}
style.Draw(position, content, id, false);
content.text = text;
}
}
else if (position.Contains(current.mousePosition))
{
GUIUtility.hotControl = id;
if (GUI.s_HotTextField != -1 && GUI.s_HotTextField != id)
{
TextEditor textEditor = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUI.s_HotTextField);
textEditor.keyboardOnScreen = null;
}
GUI.s_HotTextField = id;
if (GUIUtility.keyboardControl != id)
{
GUIUtility.keyboardControl = id;
}
editor.keyboardOnScreen = TouchScreenKeyboard.Open((secureText == null) ? content.text : secureText, TouchScreenKeyboardType.Default, true, multiline, secureText != null);
current.Use();
}
}
// Token: 0x060028F7 RID: 10487 RVA: 0x00030994 File Offset: 0x0002EB94
private static void HandleTextFieldEventForDesktop(Rect position, int id, GUIContent content, bool multiline, int maxLength, GUIStyle style, TextEditor editor)
{
Event current = Event.current;
bool flag = false;
switch (current.type)
{
case EventType.MouseDown:
if (position.Contains(current.mousePosition))
{
GUIUtility.hotControl = id;
GUIUtility.keyboardControl = id;
editor.m_HasFocus = true;
editor.MoveCursorToPosition(Event.current.mousePosition);
if (Event.current.clickCount == 2 && GUI.skin.settings.doubleClickSelectsWord)
{
editor.SelectCurrentWord();
editor.DblClickSnap(TextEditor.DblClickSnapping.WORDS);
editor.MouseDragSelectsWholeWords(true);
}
if (Event.current.clickCount == 3 && GUI.skin.settings.tripleClickSelectsLine)
{
editor.SelectCurrentParagraph();
editor.MouseDragSelectsWholeWords(true);
editor.DblClickSnap(TextEditor.DblClickSnapping.PARAGRAPHS);
}
current.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == id)
{
editor.MouseDragSelectsWholeWords(false);
GUIUtility.hotControl = 0;
current.Use();
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == id)
{
if (current.shift)
{
editor.MoveCursorToPosition(Event.current.mousePosition);
}
else
{
editor.SelectToPosition(Event.current.mousePosition);
}
current.Use();
}
break;
case EventType.KeyDown:
if (GUIUtility.keyboardControl != id)
{
return;
}
if (editor.HandleKeyEvent(current))
{
current.Use();
flag = true;
content.text = editor.text;
}
else
{
if (current.keyCode == KeyCode.Tab || current.character == '\t')
{
return;
}
char character = current.character;
if (character == '\n' && !multiline && !current.alt)
{
return;
}
Font font = style.font;
if (!font)
{
font = GUI.skin.font;
}
if (font.HasCharacter(character) || character == '\n')
{
editor.Insert(character);
flag = true;
}
else if (character == '\0')
{
if (Input.compositionString.Length > 0)
{
editor.ReplaceSelection("");
flag = true;
}
current.Use();
}
}
break;
case EventType.Repaint:
if (GUIUtility.keyboardControl != id)
{
style.Draw(position, content, id, false);
}
else
{
editor.DrawCursor(content.text);
}
break;
}
if (GUIUtility.keyboardControl == id)
{
GUIUtility.textFieldInput = true;
}
if (flag)
{
GUI.changed = true;
content.text = editor.text;
if (maxLength >= 0 && content.text.Length > maxLength)
{
content.text = content.text.Substring(0, maxLength);
}
current.Use();
}
}
// Token: 0x060028F8 RID: 10488 RVA: 0x00030C90 File Offset: 0x0002EE90
public static bool Toggle(Rect position, bool value, string text)
{
return GUI.Toggle(position, value, GUIContent.Temp(text), GUI.s_Skin.toggle);
}
// Token: 0x060028F9 RID: 10489 RVA: 0x00030CBC File Offset: 0x0002EEBC
public static bool Toggle(Rect position, bool value, Texture image)
{
return GUI.Toggle(position, value, GUIContent.Temp(image), GUI.s_Skin.toggle);
}
// Token: 0x060028FA RID: 10490 RVA: 0x00030CE8 File Offset: 0x0002EEE8
public static bool Toggle(Rect position, bool value, GUIContent content)
{
return GUI.Toggle(position, value, content, GUI.s_Skin.toggle);
}
// Token: 0x060028FB RID: 10491 RVA: 0x00030D10 File Offset: 0x0002EF10
public static bool Toggle(Rect position, bool value, string text, GUIStyle style)
{
return GUI.Toggle(position, value, GUIContent.Temp(text), style);
}
// Token: 0x060028FC RID: 10492 RVA: 0x00030D34 File Offset: 0x0002EF34
public static bool Toggle(Rect position, bool value, Texture image, GUIStyle style)
{
return GUI.Toggle(position, value, GUIContent.Temp(image), style);
}
// Token: 0x060028FD RID: 10493 RVA: 0x00030D58 File Offset: 0x0002EF58
public static bool Toggle(Rect position, bool value, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoToggle(position, GUIUtility.GetControlID(GUI.s_ToggleHash, FocusType.Passive, position), value, content, style.m_Ptr);
}
// Token: 0x060028FE RID: 10494 RVA: 0x00030D8C File Offset: 0x0002EF8C
public static bool Toggle(Rect position, int id, bool value, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoToggle(position, id, value, content, style.m_Ptr);
}
// Token: 0x060028FF RID: 10495 RVA: 0x00030DB8 File Offset: 0x0002EFB8
public static int Toolbar(Rect position, int selected, string[] texts)
{
return GUI.Toolbar(position, selected, GUIContent.Temp(texts), GUI.s_Skin.button);
}
// Token: 0x06002900 RID: 10496 RVA: 0x00030DE4 File Offset: 0x0002EFE4
public static int Toolbar(Rect position, int selected, Texture[] images)
{
return GUI.Toolbar(position, selected, GUIContent.Temp(images), GUI.s_Skin.button);
}
// Token: 0x06002901 RID: 10497 RVA: 0x00030E10 File Offset: 0x0002F010
public static int Toolbar(Rect position, int selected, GUIContent[] content)
{
return GUI.Toolbar(position, selected, content, GUI.s_Skin.button);
}
// Token: 0x06002902 RID: 10498 RVA: 0x00030E38 File Offset: 0x0002F038
public static int Toolbar(Rect position, int selected, string[] texts, GUIStyle style)
{
return GUI.Toolbar(position, selected, GUIContent.Temp(texts), style);
}
// Token: 0x06002903 RID: 10499 RVA: 0x00030E5C File Offset: 0x0002F05C
public static int Toolbar(Rect position, int selected, Texture[] images, GUIStyle style)
{
return GUI.Toolbar(position, selected, GUIContent.Temp(images), style);
}
// Token: 0x06002904 RID: 10500 RVA: 0x00030E80 File Offset: 0x0002F080
public static int Toolbar(Rect position, int selected, GUIContent[] contents, GUIStyle style)
{
GUIUtility.CheckOnGUI();
GUIStyle guistyle;
GUIStyle guistyle2;
GUIStyle guistyle3;
GUI.FindStyles(ref style, out guistyle, out guistyle2, out guistyle3, "left", "mid", "right");
return GUI.DoButtonGrid(position, selected, contents, contents.Length, style, guistyle, guistyle2, guistyle3);
}
// Token: 0x06002905 RID: 10501 RVA: 0x00030EC8 File Offset: 0x0002F0C8
public static int SelectionGrid(Rect position, int selected, string[] texts, int xCount)
{
return GUI.SelectionGrid(position, selected, GUIContent.Temp(texts), xCount, null);
}
// Token: 0x06002906 RID: 10502 RVA: 0x00030EEC File Offset: 0x0002F0EC
public static int SelectionGrid(Rect position, int selected, Texture[] images, int xCount)
{
return GUI.SelectionGrid(position, selected, GUIContent.Temp(images), xCount, null);
}
// Token: 0x06002907 RID: 10503 RVA: 0x00030F10 File Offset: 0x0002F110
public static int SelectionGrid(Rect position, int selected, GUIContent[] content, int xCount)
{
return GUI.SelectionGrid(position, selected, content, xCount, null);
}
// Token: 0x06002908 RID: 10504 RVA: 0x00030F30 File Offset: 0x0002F130
public static int SelectionGrid(Rect position, int selected, string[] texts, int xCount, GUIStyle style)
{
return GUI.SelectionGrid(position, selected, GUIContent.Temp(texts), xCount, style);
}
// Token: 0x06002909 RID: 10505 RVA: 0x00030F58 File Offset: 0x0002F158
public static int SelectionGrid(Rect position, int selected, Texture[] images, int xCount, GUIStyle style)
{
return GUI.SelectionGrid(position, selected, GUIContent.Temp(images), xCount, style);
}
// Token: 0x0600290A RID: 10506 RVA: 0x00030F80 File Offset: 0x0002F180
public static int SelectionGrid(Rect position, int selected, GUIContent[] contents, int xCount, GUIStyle style)
{
if (style == null)
{
style = GUI.s_Skin.button;
}
return GUI.DoButtonGrid(position, selected, contents, xCount, style, style, style, style);
}
// Token: 0x0600290B RID: 10507 RVA: 0x00030FBC File Offset: 0x0002F1BC
internal static void FindStyles(ref GUIStyle style, out GUIStyle firstStyle, out GUIStyle midStyle, out GUIStyle lastStyle, string first, string mid, string last)
{
if (style == null)
{
style = GUI.skin.button;
}
string name = style.name;
midStyle = GUI.skin.FindStyle(name + mid);
if (midStyle == null)
{
midStyle = style;
}
firstStyle = GUI.skin.FindStyle(name + first);
if (firstStyle == null)
{
firstStyle = midStyle;
}
lastStyle = GUI.skin.FindStyle(name + last);
if (lastStyle == null)
{
lastStyle = midStyle;
}
}
// Token: 0x0600290C RID: 10508 RVA: 0x00031044 File Offset: 0x0002F244
internal static int CalcTotalHorizSpacing(int xCount, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle)
{
int num;
if (xCount < 2)
{
num = 0;
}
else if (xCount == 2)
{
num = Mathf.Max(firstStyle.margin.right, lastStyle.margin.left);
}
else
{
int num2 = Mathf.Max(midStyle.margin.left, midStyle.margin.right);
num = Mathf.Max(firstStyle.margin.right, midStyle.margin.left) + Mathf.Max(midStyle.margin.right, lastStyle.margin.left) + num2 * (xCount - 3);
}
return num;
}
// Token: 0x0600290D RID: 10509 RVA: 0x000310EC File Offset: 0x0002F2EC
private static int DoButtonGrid(Rect position, int selected, GUIContent[] contents, int xCount, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle)
{
GUIUtility.CheckOnGUI();
int num = contents.Length;
int num2;
if (num == 0)
{
num2 = selected;
}
else if (xCount <= 0)
{
Debug.LogWarning("You are trying to create a SelectionGrid with zero or less elements to be displayed in the horizontal direction. Set xCount to a positive value.");
num2 = selected;
}
else
{
int controlID = GUIUtility.GetControlID(GUI.s_ButtonGridHash, FocusType.Passive, position);
int num3 = num / xCount;
if (num % xCount != 0)
{
num3++;
}
float num4 = (float)GUI.CalcTotalHorizSpacing(xCount, style, firstStyle, midStyle, lastStyle);
float num5 = (float)(Mathf.Max(style.margin.top, style.margin.bottom) * (num3 - 1));
float num6 = (position.width - num4) / (float)xCount;
float num7 = (position.height - num5) / (float)num3;
if (style.fixedWidth != 0f)
{
num6 = style.fixedWidth;
}
if (style.fixedHeight != 0f)
{
num7 = style.fixedHeight;
}
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (position.Contains(Event.current.mousePosition))
{
Rect[] array = GUI.CalcMouseRects(position, num, xCount, num6, num7, style, firstStyle, midStyle, lastStyle, false);
if (GUI.GetButtonGridMouseSelection(array, Event.current.mousePosition, true) != -1)
{
GUIUtility.hotControl = controlID;
Event.current.Use();
}
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == controlID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
Rect[] array = GUI.CalcMouseRects(position, num, xCount, num6, num7, style, firstStyle, midStyle, lastStyle, false);
int buttonGridMouseSelection = GUI.GetButtonGridMouseSelection(array, Event.current.mousePosition, true);
GUI.changed = true;
return buttonGridMouseSelection;
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == controlID)
{
Event.current.Use();
}
break;
case EventType.Repaint:
{
GUIStyle guistyle = null;
GUIClip.Push(position, Vector2.zero, Vector2.zero, false);
position = new Rect(0f, 0f, position.width, position.height);
Rect[] array = GUI.CalcMouseRects(position, num, xCount, num6, num7, style, firstStyle, midStyle, lastStyle, false);
int buttonGridMouseSelection2 = GUI.GetButtonGridMouseSelection(array, Event.current.mousePosition, controlID == GUIUtility.hotControl);
bool flag = position.Contains(Event.current.mousePosition);
GUIUtility.mouseUsed = GUIUtility.mouseUsed || flag;
for (int i = 0; i < num; i++)
{
GUIStyle guistyle2;
if (i != 0)
{
guistyle2 = midStyle;
}
else
{
guistyle2 = firstStyle;
}
if (i == num - 1)
{
guistyle2 = lastStyle;
}
if (num == 1)
{
guistyle2 = style;
}
if (i != selected)
{
guistyle2.Draw(array[i], contents[i], i == buttonGridMouseSelection2 && (GUI.enabled || controlID == GUIUtility.hotControl) && (controlID == GUIUtility.hotControl || GUIUtility.hotControl == 0), controlID == GUIUtility.hotControl && GUI.enabled, false, false);
}
else
{
guistyle = guistyle2;
}
}
if (selected < num && selected > -1)
{
guistyle.Draw(array[selected], contents[selected], selected == buttonGridMouseSelection2 && (GUI.enabled || controlID == GUIUtility.hotControl) && (controlID == GUIUtility.hotControl || GUIUtility.hotControl == 0), controlID == GUIUtility.hotControl, true, false);
}
if (buttonGridMouseSelection2 >= 0 && !string.IsNullOrEmpty(contents[buttonGridMouseSelection2].tooltip))
{
GUIStyle.SetMouseTooltip(contents[buttonGridMouseSelection2].tooltip, array[buttonGridMouseSelection2]);
}
GUIClip.Pop();
break;
}
}
num2 = selected;
}
return num2;
}
// Token: 0x0600290E RID: 10510 RVA: 0x000314D0 File Offset: 0x0002F6D0
private static Rect[] CalcMouseRects(Rect position, int count, int xCount, float elemWidth, float elemHeight, GUIStyle style, GUIStyle firstStyle, GUIStyle midStyle, GUIStyle lastStyle, bool addBorders)
{
int num = 0;
int num2 = 0;
float num3 = position.xMin;
float num4 = position.yMin;
GUIStyle guistyle = style;
Rect[] array = new Rect[count];
if (count > 1)
{
guistyle = firstStyle;
}
for (int i = 0; i < count; i++)
{
if (!addBorders)
{
array[i] = new Rect(num3, num4, elemWidth, elemHeight);
}
else
{
array[i] = guistyle.margin.Add(new Rect(num3, num4, elemWidth, elemHeight));
}
array[i].width = Mathf.Round(array[i].xMax) - Mathf.Round(array[i].x);
array[i].x = Mathf.Round(array[i].x);
GUIStyle guistyle2 = midStyle;
if (i == count - 2)
{
guistyle2 = lastStyle;
}
num3 += elemWidth + (float)Mathf.Max(guistyle.margin.right, guistyle2.margin.left);
num2++;
if (num2 >= xCount)
{
num++;
num2 = 0;
num4 += elemHeight + (float)Mathf.Max(style.margin.top, style.margin.bottom);
num3 = position.xMin;
}
}
return array;
}
// Token: 0x0600290F RID: 10511 RVA: 0x00031640 File Offset: 0x0002F840
private static int GetButtonGridMouseSelection(Rect[] buttonRects, Vector2 mousePos, bool findNearest)
{
for (int i = 0; i < buttonRects.Length; i++)
{
if (buttonRects[i].Contains(mousePos))
{
return i;
}
}
if (!findNearest)
{
return -1;
}
float num = 10000000f;
int num2 = -1;
for (int j = 0; j < buttonRects.Length; j++)
{
Rect rect = buttonRects[j];
Vector2 vector = new Vector2(Mathf.Clamp(mousePos.x, rect.xMin, rect.xMax), Mathf.Clamp(mousePos.y, rect.yMin, rect.yMax));
float sqrMagnitude = (mousePos - vector).sqrMagnitude;
if (sqrMagnitude < num)
{
num2 = j;
num = sqrMagnitude;
}
}
return num2;
}
// Token: 0x06002910 RID: 10512 RVA: 0x00031724 File Offset: 0x0002F924
public static float HorizontalSlider(Rect position, float value, float leftValue, float rightValue)
{
return GUI.Slider(position, value, 0f, leftValue, rightValue, GUI.skin.horizontalSlider, GUI.skin.horizontalSliderThumb, true, 0);
}
// Token: 0x06002911 RID: 10513 RVA: 0x00031760 File Offset: 0x0002F960
public static float HorizontalSlider(Rect position, float value, float leftValue, float rightValue, GUIStyle slider, GUIStyle thumb)
{
return GUI.Slider(position, value, 0f, leftValue, rightValue, slider, thumb, true, 0);
}
// Token: 0x06002912 RID: 10514 RVA: 0x0003178C File Offset: 0x0002F98C
public static float VerticalSlider(Rect position, float value, float topValue, float bottomValue)
{
return GUI.Slider(position, value, 0f, topValue, bottomValue, GUI.skin.verticalSlider, GUI.skin.verticalSliderThumb, false, 0);
}
// Token: 0x06002913 RID: 10515 RVA: 0x000317C8 File Offset: 0x0002F9C8
public static float VerticalSlider(Rect position, float value, float topValue, float bottomValue, GUIStyle slider, GUIStyle thumb)
{
return GUI.Slider(position, value, 0f, topValue, bottomValue, slider, thumb, false, 0);
}
// Token: 0x06002914 RID: 10516 RVA: 0x000317F4 File Offset: 0x0002F9F4
public static float Slider(Rect position, float value, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
{
GUIUtility.CheckOnGUI();
if (id == 0)
{
id = GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive, position);
}
SliderHandler sliderHandler = new SliderHandler(position, value, size, start, end, slider, thumb, horiz, id);
return sliderHandler.Handle();
}
// Token: 0x06002915 RID: 10517 RVA: 0x00031844 File Offset: 0x0002FA44
public static float HorizontalScrollbar(Rect position, float value, float size, float leftValue, float rightValue)
{
return GUI.Scroller(position, value, size, leftValue, rightValue, GUI.skin.horizontalScrollbar, GUI.skin.horizontalScrollbarThumb, GUI.skin.horizontalScrollbarLeftButton, GUI.skin.horizontalScrollbarRightButton, true);
}
// Token: 0x06002916 RID: 10518 RVA: 0x00031890 File Offset: 0x0002FA90
public static float HorizontalScrollbar(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle style)
{
return GUI.Scroller(position, value, size, leftValue, rightValue, style, GUI.skin.GetStyle(style.name + "thumb"), GUI.skin.GetStyle(style.name + "leftbutton"), GUI.skin.GetStyle(style.name + "rightbutton"), true);
}
// Token: 0x06002917 RID: 10519 RVA: 0x00031904 File Offset: 0x0002FB04
internal static bool ScrollerRepeatButton(int scrollerID, Rect rect, GUIStyle style)
{
bool flag = false;
if (GUI.DoRepeatButton(rect, GUIContent.none, style, FocusType.Passive))
{
bool flag2 = GUI.s_ScrollControlId != scrollerID;
GUI.s_ScrollControlId = scrollerID;
if (flag2)
{
flag = true;
GUI.nextScrollStepTime = DateTime.Now.AddMilliseconds(250.0);
}
else if (DateTime.Now >= GUI.nextScrollStepTime)
{
flag = true;
GUI.nextScrollStepTime = DateTime.Now.AddMilliseconds(30.0);
}
if (Event.current.type == EventType.Repaint)
{
GUI.InternalRepaintEditorWindow();
}
}
return flag;
}
// Token: 0x06002918 RID: 10520 RVA: 0x000319B8 File Offset: 0x0002FBB8
public static float VerticalScrollbar(Rect position, float value, float size, float topValue, float bottomValue)
{
return GUI.Scroller(position, value, size, topValue, bottomValue, GUI.skin.verticalScrollbar, GUI.skin.verticalScrollbarThumb, GUI.skin.verticalScrollbarUpButton, GUI.skin.verticalScrollbarDownButton, false);
}
// Token: 0x06002919 RID: 10521 RVA: 0x00031A04 File Offset: 0x0002FC04
public static float VerticalScrollbar(Rect position, float value, float size, float topValue, float bottomValue, GUIStyle style)
{
return GUI.Scroller(position, value, size, topValue, bottomValue, style, GUI.skin.GetStyle(style.name + "thumb"), GUI.skin.GetStyle(style.name + "upbutton"), GUI.skin.GetStyle(style.name + "downbutton"), false);
}
// Token: 0x0600291A RID: 10522 RVA: 0x00031A78 File Offset: 0x0002FC78
internal static float Scroller(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle slider, GUIStyle thumb, GUIStyle leftButton, GUIStyle rightButton, bool horiz)
{
GUIUtility.CheckOnGUI();
int controlID = GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive, position);
Rect rect;
Rect rect2;
Rect rect3;
if (horiz)
{
rect = new Rect(position.x + leftButton.fixedWidth, position.y, position.width - leftButton.fixedWidth - rightButton.fixedWidth, position.height);
rect2 = new Rect(position.x, position.y, leftButton.fixedWidth, position.height);
rect3 = new Rect(position.xMax - rightButton.fixedWidth, position.y, rightButton.fixedWidth, position.height);
}
else
{
rect = new Rect(position.x, position.y + leftButton.fixedHeight, position.width, position.height - leftButton.fixedHeight - rightButton.fixedHeight);
rect2 = new Rect(position.x, position.y, position.width, leftButton.fixedHeight);
rect3 = new Rect(position.x, position.yMax - rightButton.fixedHeight, position.width, rightButton.fixedHeight);
}
value = GUI.Slider(rect, value, size, leftValue, rightValue, slider, thumb, horiz, controlID);
bool flag = false;
if (Event.current.type == EventType.MouseUp)
{
flag = true;
}
if (GUI.ScrollerRepeatButton(controlID, rect2, leftButton))
{
value -= GUI.s_ScrollStepSize * ((leftValue >= rightValue) ? (-1f) : 1f);
}
if (GUI.ScrollerRepeatButton(controlID, rect3, rightButton))
{
value += GUI.s_ScrollStepSize * ((leftValue >= rightValue) ? (-1f) : 1f);
}
if (flag && Event.current.type == EventType.Used)
{
GUI.s_ScrollControlId = 0;
}
if (leftValue < rightValue)
{
value = Mathf.Clamp(value, leftValue, rightValue - size);
}
else
{
value = Mathf.Clamp(value, rightValue, leftValue - size);
}
return value;
}
// Token: 0x0600291B RID: 10523 RVA: 0x00031C94 File Offset: 0x0002FE94
public static void BeginClip(Rect position, Vector2 scrollOffset, Vector2 renderOffset, bool resetOffset)
{
GUIUtility.CheckOnGUI();
GUIClip.Push(position, scrollOffset, renderOffset, resetOffset);
}
// Token: 0x0600291C RID: 10524 RVA: 0x00031CA8 File Offset: 0x0002FEA8
public static void BeginGroup(Rect position)
{
GUI.BeginGroup(position, GUIContent.none, GUIStyle.none);
}
// Token: 0x0600291D RID: 10525 RVA: 0x00031CBC File Offset: 0x0002FEBC
public static void BeginGroup(Rect position, string text)
{
GUI.BeginGroup(position, GUIContent.Temp(text), GUIStyle.none);
}
// Token: 0x0600291E RID: 10526 RVA: 0x00031CD0 File Offset: 0x0002FED0
public static void BeginGroup(Rect position, Texture image)
{
GUI.BeginGroup(position, GUIContent.Temp(image), GUIStyle.none);
}
// Token: 0x0600291F RID: 10527 RVA: 0x00031CE4 File Offset: 0x0002FEE4
public static void BeginGroup(Rect position, GUIContent content)
{
GUI.BeginGroup(position, content, GUIStyle.none);
}
// Token: 0x06002920 RID: 10528 RVA: 0x00031CF4 File Offset: 0x0002FEF4
public static void BeginGroup(Rect position, GUIStyle style)
{
GUI.BeginGroup(position, GUIContent.none, style);
}
// Token: 0x06002921 RID: 10529 RVA: 0x00031D04 File Offset: 0x0002FF04
public static void BeginGroup(Rect position, string text, GUIStyle style)
{
GUI.BeginGroup(position, GUIContent.Temp(text), style);
}
// Token: 0x06002922 RID: 10530 RVA: 0x00031D14 File Offset: 0x0002FF14
public static void BeginGroup(Rect position, Texture image, GUIStyle style)
{
GUI.BeginGroup(position, GUIContent.Temp(image), style);
}
// Token: 0x06002923 RID: 10531 RVA: 0x00031D24 File Offset: 0x0002FF24
public static void BeginGroup(Rect position, GUIContent content, GUIStyle style)
{
GUI.BeginGroup(position, content, style, Vector2.zero);
}
// Token: 0x06002924 RID: 10532 RVA: 0x00031D34 File Offset: 0x0002FF34
internal static void BeginGroup(Rect position, GUIContent content, GUIStyle style, Vector2 scrollOffset)
{
GUIUtility.CheckOnGUI();
int controlID = GUIUtility.GetControlID(GUI.s_BeginGroupHash, FocusType.Passive);
if (content != GUIContent.none || style != GUIStyle.none)
{
EventType type = Event.current.type;
if (type != EventType.Repaint)
{
if (position.Contains(Event.current.mousePosition))
{
GUIUtility.mouseUsed = true;
}
}
else
{
style.Draw(position, content, controlID);
}
}
GUIClip.Push(position, scrollOffset, Vector2.zero, false);
}
// Token: 0x06002925 RID: 10533 RVA: 0x00031DC0 File Offset: 0x0002FFC0
public static void EndGroup()
{
GUIUtility.CheckOnGUI();
GUIClip.Internal_Pop();
}
// Token: 0x06002926 RID: 10534 RVA: 0x00031DD0 File Offset: 0x0002FFD0
public static void BeginClip(Rect position)
{
GUIUtility.CheckOnGUI();
GUIClip.Push(position, Vector2.zero, Vector2.zero, false);
}
// Token: 0x06002927 RID: 10535 RVA: 0x00031DEC File Offset: 0x0002FFEC
public static void EndClip()
{
GUIUtility.CheckOnGUI();
GUIClip.Pop();
}
// Token: 0x06002928 RID: 10536 RVA: 0x00031DFC File Offset: 0x0002FFFC
public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect)
{
return GUI.BeginScrollView(position, scrollPosition, viewRect, false, false, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar, GUI.skin.scrollView);
}
// Token: 0x06002929 RID: 10537 RVA: 0x00031E3C File Offset: 0x0003003C
public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical)
{
return GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar, GUI.skin.scrollView);
}
// Token: 0x0600292A RID: 10538 RVA: 0x00031E7C File Offset: 0x0003007C
public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
{
return GUI.BeginScrollView(position, scrollPosition, viewRect, false, false, horizontalScrollbar, verticalScrollbar, GUI.skin.scrollView);
}
// Token: 0x0600292B RID: 10539 RVA: 0x00031EA8 File Offset: 0x000300A8
public static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
{
return GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar, GUI.skin.scrollView);
}
// Token: 0x0600292C RID: 10540 RVA: 0x00031ED8 File Offset: 0x000300D8
protected static Vector2 DoBeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
{
return GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar, background);
}
// Token: 0x0600292D RID: 10541 RVA: 0x00031F00 File Offset: 0x00030100
internal static Vector2 BeginScrollView(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
{
GUIUtility.CheckOnGUI();
int controlID = GUIUtility.GetControlID(GUI.s_ScrollviewHash, FocusType.Passive);
ScrollViewState scrollViewState = (ScrollViewState)GUIUtility.GetStateObject(typeof(ScrollViewState), controlID);
if (scrollViewState.apply)
{
scrollPosition = scrollViewState.scrollPosition;
scrollViewState.apply = false;
}
scrollViewState.position = position;
scrollViewState.scrollPosition = scrollPosition;
scrollViewState.visibleRect = (scrollViewState.viewRect = viewRect);
scrollViewState.visibleRect.width = position.width;
scrollViewState.visibleRect.height = position.height;
GUI.s_ScrollViewStates.Push(scrollViewState);
Rect rect = new Rect(position);
EventType type = Event.current.type;
if (type != EventType.Layout)
{
if (type != EventType.Used)
{
bool flag = alwaysShowVertical;
bool flag2 = alwaysShowHorizontal;
if (flag2 || viewRect.width > rect.width)
{
scrollViewState.visibleRect.height = position.height - horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
rect.height -= horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
flag2 = true;
}
if (flag || viewRect.height > rect.height)
{
scrollViewState.visibleRect.width = position.width - verticalScrollbar.fixedWidth + (float)verticalScrollbar.margin.left;
rect.width -= verticalScrollbar.fixedWidth + (float)verticalScrollbar.margin.left;
flag = true;
if (!flag2 && viewRect.width > rect.width)
{
scrollViewState.visibleRect.height = position.height - horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
rect.height -= horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
flag2 = true;
}
}
if (Event.current.type == EventType.Repaint && background != GUIStyle.none)
{
background.Draw(position, position.Contains(Event.current.mousePosition), false, flag2 && flag, false);
}
if (flag2 && horizontalScrollbar != GUIStyle.none)
{
scrollPosition.x = GUI.HorizontalScrollbar(new Rect(position.x, position.yMax - horizontalScrollbar.fixedHeight, rect.width, horizontalScrollbar.fixedHeight), scrollPosition.x, Mathf.Min(rect.width, viewRect.width), 0f, viewRect.width, horizontalScrollbar);
}
else
{
GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
if (horizontalScrollbar != GUIStyle.none)
{
scrollPosition.x = 0f;
}
else
{
scrollPosition.x = Mathf.Clamp(scrollPosition.x, 0f, Mathf.Max(viewRect.width - position.width, 0f));
}
}
if (flag && verticalScrollbar != GUIStyle.none)
{
scrollPosition.y = GUI.VerticalScrollbar(new Rect(rect.xMax + (float)verticalScrollbar.margin.left, rect.y, verticalScrollbar.fixedWidth, rect.height), scrollPosition.y, Mathf.Min(rect.height, viewRect.height), 0f, viewRect.height, verticalScrollbar);
}
else
{
GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
if (verticalScrollbar != GUIStyle.none)
{
scrollPosition.y = 0f;
}
else
{
scrollPosition.y = Mathf.Clamp(scrollPosition.y, 0f, Mathf.Max(viewRect.height - position.height, 0f));
}
}
}
}
else
{
GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
}
GUIClip.Push(rect, new Vector2(Mathf.Round(-scrollPosition.x - viewRect.x), Mathf.Round(-scrollPosition.y - viewRect.y)), Vector2.zero, false);
return scrollPosition;
}
// Token: 0x0600292E RID: 10542 RVA: 0x000323CC File Offset: 0x000305CC
public static void EndScrollView()
{
GUI.EndScrollView(true);
}
// Token: 0x0600292F RID: 10543 RVA: 0x000323D8 File Offset: 0x000305D8
public static void EndScrollView(bool handleScrollWheel)
{
GUIUtility.CheckOnGUI();
ScrollViewState scrollViewState = (ScrollViewState)GUI.s_ScrollViewStates.Peek();
GUIClip.Pop();
GUI.s_ScrollViewStates.Pop();
if (handleScrollWheel && Event.current.type == EventType.ScrollWheel && scrollViewState.position.Contains(Event.current.mousePosition))
{
scrollViewState.scrollPosition.x = Mathf.Clamp(scrollViewState.scrollPosition.x + Event.current.delta.x * 20f, 0f, scrollViewState.viewRect.width - scrollViewState.visibleRect.width);
scrollViewState.scrollPosition.y = Mathf.Clamp(scrollViewState.scrollPosition.y + Event.current.delta.y * 20f, 0f, scrollViewState.viewRect.height - scrollViewState.visibleRect.height);
if (scrollViewState.scrollPosition.x < 0f)
{
scrollViewState.scrollPosition.x = 0f;
}
if (scrollViewState.scrollPosition.y < 0f)
{
scrollViewState.scrollPosition.y = 0f;
}
scrollViewState.apply = true;
Event.current.Use();
}
}
// Token: 0x06002930 RID: 10544 RVA: 0x00032538 File Offset: 0x00030738
internal static ScrollViewState GetTopScrollView()
{
ScrollViewState scrollViewState;
if (GUI.s_ScrollViewStates.Count != 0)
{
scrollViewState = (ScrollViewState)GUI.s_ScrollViewStates.Peek();
}
else
{
scrollViewState = null;
}
return scrollViewState;
}
// Token: 0x06002931 RID: 10545 RVA: 0x00032574 File Offset: 0x00030774
public static void ScrollTo(Rect position)
{
ScrollViewState topScrollView = GUI.GetTopScrollView();
if (topScrollView != null)
{
topScrollView.ScrollTo(position);
}
}
// Token: 0x06002932 RID: 10546 RVA: 0x00032598 File Offset: 0x00030798
public static bool ScrollTowards(Rect position, float maxDelta)
{
ScrollViewState topScrollView = GUI.GetTopScrollView();
return topScrollView != null && topScrollView.ScrollTowards(position, maxDelta);
}
// Token: 0x06002933 RID: 10547 RVA: 0x000325C8 File Offset: 0x000307C8
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, string text)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, GUIContent.Temp(text), GUI.skin.window, GUI.skin, true);
}
// Token: 0x06002934 RID: 10548 RVA: 0x00032600 File Offset: 0x00030800
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, Texture image)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, GUIContent.Temp(image), GUI.skin.window, GUI.skin, true);
}
// Token: 0x06002935 RID: 10549 RVA: 0x00032638 File Offset: 0x00030838
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, GUIContent content)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, content, GUI.skin.window, GUI.skin, true);
}
// Token: 0x06002936 RID: 10550 RVA: 0x0003266C File Offset: 0x0003086C
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, string text, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, GUIContent.Temp(text), style, GUI.skin, true);
}
// Token: 0x06002937 RID: 10551 RVA: 0x0003269C File Offset: 0x0003089C
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, Texture image, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, GUIContent.Temp(image), style, GUI.skin, true);
}
// Token: 0x06002938 RID: 10552 RVA: 0x000326CC File Offset: 0x000308CC
public static Rect Window(int id, Rect clientRect, GUI.WindowFunction func, GUIContent title, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoWindow(id, clientRect, func, title, style, GUI.skin, true);
}
// Token: 0x06002939 RID: 10553 RVA: 0x000326F8 File Offset: 0x000308F8
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, string text)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, GUIContent.Temp(text), GUI.skin.window, GUI.skin);
}
// Token: 0x0600293A RID: 10554 RVA: 0x00032730 File Offset: 0x00030930
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, Texture image)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, GUIContent.Temp(image), GUI.skin.window, GUI.skin);
}
// Token: 0x0600293B RID: 10555 RVA: 0x00032768 File Offset: 0x00030968
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, GUIContent content)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, content, GUI.skin.window, GUI.skin);
}
// Token: 0x0600293C RID: 10556 RVA: 0x0003279C File Offset: 0x0003099C
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, string text, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, GUIContent.Temp(text), style, GUI.skin);
}
// Token: 0x0600293D RID: 10557 RVA: 0x000327CC File Offset: 0x000309CC
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, Texture image, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, GUIContent.Temp(image), style, GUI.skin);
}
// Token: 0x0600293E RID: 10558 RVA: 0x000327FC File Offset: 0x000309FC
public static Rect ModalWindow(int id, Rect clientRect, GUI.WindowFunction func, GUIContent content, GUIStyle style)
{
GUIUtility.CheckOnGUI();
return GUI.DoModalWindow(id, clientRect, func, content, style, GUI.skin);
}
// Token: 0x0600293F RID: 10559 RVA: 0x00032828 File Offset: 0x00030A28
private static Rect DoWindow(int id, Rect clientRect, GUI.WindowFunction func, GUIContent title, GUIStyle style, GUISkin skin, bool forceRectOnLayout)
{
return GUI.Internal_DoWindow(id, GUIUtility.s_OriginalID, clientRect, func, title, style, skin, forceRectOnLayout);
}
// Token: 0x06002940 RID: 10560 RVA: 0x00032854 File Offset: 0x00030A54
private static Rect DoModalWindow(int id, Rect clientRect, GUI.WindowFunction func, GUIContent content, GUIStyle style, GUISkin skin)
{
return GUI.Internal_DoModalWindow(id, GUIUtility.s_OriginalID, clientRect, func, content, style, skin);
}
// Token: 0x06002941 RID: 10561 RVA: 0x0003287C File Offset: 0x00030A7C
[RequiredByNativeCode]
internal static void CallWindowDelegate(GUI.WindowFunction func, int id, int instanceID, GUISkin _skin, int forceRect, float width, float height, GUIStyle style)
{
GUILayoutUtility.SelectIDList(id, true);
GUISkin skin = GUI.skin;
if (Event.current.type == EventType.Layout)
{
if (forceRect != 0)
{
GUILayoutOption[] array = new GUILayoutOption[]
{
GUILayout.Width(width),
GUILayout.Height(height)
};
GUILayoutUtility.BeginWindow(id, style, array);
}
else
{
GUILayoutUtility.BeginWindow(id, style, null);
}
}
else
{
GUILayoutUtility.BeginWindow(id, GUIStyle.none, null);
}
GUI.skin = _skin;
func(id);
if (Event.current.type == EventType.Layout)
{
GUILayoutUtility.Layout();
}
GUI.skin = skin;
}
// Token: 0x06002942 RID: 10562 RVA: 0x00032924 File Offset: 0x00030B24
public static void DragWindow()
{
GUI.DragWindow(new Rect(0f, 0f, 10000f, 10000f));
}
// Token: 0x06002943 RID: 10563 RVA: 0x00032948 File Offset: 0x00030B48
internal static void BeginWindows(int skinMode, int editorWindowInstanceID)
{
GUILayoutGroup topLevel = GUILayoutUtility.current.topLevel;
GenericStack layoutGroups = GUILayoutUtility.current.layoutGroups;
GUILayoutGroup windows = GUILayoutUtility.current.windows;
Matrix4x4 matrix = GUI.matrix;
GUI.Internal_BeginWindows();
GUI.matrix = matrix;
GUILayoutUtility.current.topLevel = topLevel;
GUILayoutUtility.current.layoutGroups = layoutGroups;
GUILayoutUtility.current.windows = windows;
}
// Token: 0x06002944 RID: 10564 RVA: 0x000329AC File Offset: 0x00030BAC
internal static void EndWindows()
{
GUILayoutGroup topLevel = GUILayoutUtility.current.topLevel;
GenericStack layoutGroups = GUILayoutUtility.current.layoutGroups;
GUILayoutGroup windows = GUILayoutUtility.current.windows;
GUI.Internal_EndWindows();
GUILayoutUtility.current.topLevel = topLevel;
GUILayoutUtility.current.layoutGroups = layoutGroups;
GUILayoutUtility.current.windows = windows;
}
// Token: 0x170009A8 RID: 2472
// (get) Token: 0x06002945 RID: 10565 RVA: 0x00032A04 File Offset: 0x00030C04
// (set) Token: 0x06002946 RID: 10566 RVA: 0x00032A24 File Offset: 0x00030C24
public static Color color
{
get
{
Color color;
GUI.INTERNAL_get_color(out color);
return color;
}
set
{
GUI.INTERNAL_set_color(ref value);
}
}
// Token: 0x06002947 RID: 10567
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_get_color(out Color value);
// Token: 0x06002948 RID: 10568
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_set_color(ref Color value);
// Token: 0x170009A9 RID: 2473
// (get) Token: 0x06002949 RID: 10569 RVA: 0x00032A30 File Offset: 0x00030C30
// (set) Token: 0x0600294A RID: 10570 RVA: 0x00032A50 File Offset: 0x00030C50
public static Color backgroundColor
{
get
{
Color color;
GUI.INTERNAL_get_backgroundColor(out color);
return color;
}
set
{
GUI.INTERNAL_set_backgroundColor(ref value);
}
}
// Token: 0x0600294B RID: 10571
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_get_backgroundColor(out Color value);
// Token: 0x0600294C RID: 10572
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_set_backgroundColor(ref Color value);
// Token: 0x170009AA RID: 2474
// (get) Token: 0x0600294D RID: 10573 RVA: 0x00032A5C File Offset: 0x00030C5C
// (set) Token: 0x0600294E RID: 10574 RVA: 0x00032A7C File Offset: 0x00030C7C
public static Color contentColor
{
get
{
Color color;
GUI.INTERNAL_get_contentColor(out color);
return color;
}
set
{
GUI.INTERNAL_set_contentColor(ref value);
}
}
// Token: 0x0600294F RID: 10575
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_get_contentColor(out Color value);
// Token: 0x06002950 RID: 10576
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_set_contentColor(ref Color value);
// Token: 0x170009AB RID: 2475
// (get) Token: 0x06002951 RID: 10577
// (set) Token: 0x06002952 RID: 10578
public static extern bool changed
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
set;
}
// Token: 0x170009AC RID: 2476
// (get) Token: 0x06002953 RID: 10579
// (set) Token: 0x06002954 RID: 10580
public static extern bool enabled
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
set;
}
// Token: 0x06002955 RID: 10581
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern string Internal_GetTooltip();
// Token: 0x06002956 RID: 10582
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void Internal_SetTooltip(string value);
// Token: 0x06002957 RID: 10583
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern string Internal_GetMouseTooltip();
// Token: 0x170009AD RID: 2477
// (get) Token: 0x06002958 RID: 10584
// (set) Token: 0x06002959 RID: 10585
public static extern int depth
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
set;
}
// Token: 0x0600295A RID: 10586 RVA: 0x00032A88 File Offset: 0x00030C88
private static void DoLabel(Rect position, GUIContent content, IntPtr style)
{
GUI.INTERNAL_CALL_DoLabel(ref position, content, style);
}
// Token: 0x0600295B RID: 10587
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_DoLabel(ref Rect position, GUIContent content, IntPtr style);
// Token: 0x0600295C RID: 10588
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void InitializeGUIClipTexture();
// Token: 0x170009AE RID: 2478
// (get) Token: 0x0600295D RID: 10589
internal static extern Material blendMaterial
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
}
// Token: 0x170009AF RID: 2479
// (get) Token: 0x0600295E RID: 10590
internal static extern Material blitMaterial
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
}
// Token: 0x170009B0 RID: 2480
// (get) Token: 0x0600295F RID: 10591
internal static extern Material roundedRectMaterial
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
}
// Token: 0x06002960 RID: 10592 RVA: 0x00032A94 File Offset: 0x00030C94
private static bool DoButton(Rect position, GUIContent content, IntPtr style)
{
return GUI.INTERNAL_CALL_DoButton(ref position, content, style);
}
// Token: 0x06002961 RID: 10593
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_DoButton(ref Rect position, GUIContent content, IntPtr style);
// Token: 0x06002962 RID: 10594
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void SetNextControlName(string name);
// Token: 0x06002963 RID: 10595
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern string GetNameOfFocusedControl();
// Token: 0x06002964 RID: 10596
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void FocusControl(string name);
// Token: 0x06002965 RID: 10597 RVA: 0x00032AB4 File Offset: 0x00030CB4
internal static bool DoToggle(Rect position, int id, bool value, GUIContent content, IntPtr style)
{
return GUI.INTERNAL_CALL_DoToggle(ref position, id, value, content, style);
}
// Token: 0x06002966 RID: 10598
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_DoToggle(ref Rect position, int id, bool value, GUIContent content, IntPtr style);
// Token: 0x170009B1 RID: 2481
// (get) Token: 0x06002967 RID: 10599
internal static extern bool usePageScrollbars
{
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
get;
}
// Token: 0x06002968 RID: 10600
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void InternalRepaintEditorWindow();
// Token: 0x06002969 RID: 10601 RVA: 0x00032AD8 File Offset: 0x00030CD8
private static Rect Internal_DoModalWindow(int id, int instanceID, Rect clientRect, GUI.WindowFunction func, GUIContent content, GUIStyle style, GUISkin skin)
{
Rect rect;
GUI.INTERNAL_CALL_Internal_DoModalWindow(id, instanceID, ref clientRect, func, content, style, skin, out rect);
return rect;
}
// Token: 0x0600296A RID: 10602
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_Internal_DoModalWindow(int id, int instanceID, ref Rect clientRect, GUI.WindowFunction func, GUIContent content, GUIStyle style, GUISkin skin, out Rect value);
// Token: 0x0600296B RID: 10603 RVA: 0x00032B00 File Offset: 0x00030D00
private static Rect Internal_DoWindow(int id, int instanceID, Rect clientRect, GUI.WindowFunction func, GUIContent title, GUIStyle style, GUISkin skin, bool forceRectOnLayout)
{
Rect rect;
GUI.INTERNAL_CALL_Internal_DoWindow(id, instanceID, ref clientRect, func, title, style, skin, forceRectOnLayout, out rect);
return rect;
}
// Token: 0x0600296C RID: 10604
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_Internal_DoWindow(int id, int instanceID, ref Rect clientRect, GUI.WindowFunction func, GUIContent title, GUIStyle style, GUISkin skin, bool forceRectOnLayout, out Rect value);
// Token: 0x0600296D RID: 10605 RVA: 0x00032B2C File Offset: 0x00030D2C
public static void DragWindow(Rect position)
{
GUI.INTERNAL_CALL_DragWindow(ref position);
}
// Token: 0x0600296E RID: 10606
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_DragWindow(ref Rect position);
// Token: 0x0600296F RID: 10607
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void BringWindowToFront(int windowID);
// Token: 0x06002970 RID: 10608
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void BringWindowToBack(int windowID);
// Token: 0x06002971 RID: 10609
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void FocusWindow(int windowID);
// Token: 0x06002972 RID: 10610
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern void UnfocusWindow();
// Token: 0x06002973 RID: 10611
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void Internal_BeginWindows();
// Token: 0x06002974 RID: 10612
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void Internal_EndWindows();
// Token: 0x0400072B RID: 1835
private static float s_ScrollStepSize = 10f;
// Token: 0x0400072C RID: 1836
private static int s_ScrollControlId;
// Token: 0x0400072D RID: 1837
private static int s_HotTextField = -1;
// Token: 0x0400072E RID: 1838
private static readonly int s_BoxHash = "Box".GetHashCode();
// Token: 0x0400072F RID: 1839
private static readonly int s_RepeatButtonHash = "repeatButton".GetHashCode();
// Token: 0x04000730 RID: 1840
private static readonly int s_ToggleHash = "Toggle".GetHashCode();
// Token: 0x04000731 RID: 1841
private static readonly int s_ButtonGridHash = "ButtonGrid".GetHashCode();
// Token: 0x04000732 RID: 1842
private static readonly int s_SliderHash = "Slider".GetHashCode();
// Token: 0x04000733 RID: 1843
private static readonly int s_BeginGroupHash = "BeginGroup".GetHashCode();
// Token: 0x04000734 RID: 1844
private static readonly int s_ScrollviewHash = "scrollView".GetHashCode();
// Token: 0x04000737 RID: 1847
private static GUISkin s_Skin;
// Token: 0x04000738 RID: 1848
internal static Rect s_ToolTipRect;
// Token: 0x04000739 RID: 1849
private static GenericStack s_ScrollViewStates = new GenericStack();
// Token: 0x02000259 RID: 601
// (Invoke) Token: 0x06002976 RID: 10614
public delegate void WindowFunction(int id);
// Token: 0x0200025A RID: 602
public abstract class Scope : IDisposable
{
// Token: 0x0600297A RID: 10618
protected abstract void CloseScope();
// Token: 0x0600297B RID: 10619 RVA: 0x00032B40 File Offset: 0x00030D40
~Scope()
{
if (!this.m_Disposed)
{
Debug.LogError("Scope was not disposed! You should use the 'using' keyword or manually call Dispose.");
}
}
// Token: 0x0600297C RID: 10620 RVA: 0x00032B80 File Offset: 0x00030D80
public void Dispose()
{
if (!this.m_Disposed)
{
this.m_Disposed = true;
if (!GUIUtility.guiIsExiting)
{
this.CloseScope();
}
}
}
// Token: 0x0400073A RID: 1850
private bool m_Disposed;
}
// Token: 0x0200025B RID: 603
public class GroupScope : GUI.Scope
{
// Token: 0x0600297D RID: 10621 RVA: 0x00032BAC File Offset: 0x00030DAC
public GroupScope(Rect position)
{
GUI.BeginGroup(position);
}
// Token: 0x0600297E RID: 10622 RVA: 0x00032BBC File Offset: 0x00030DBC
public GroupScope(Rect position, string text)
{
GUI.BeginGroup(position, text);
}
// Token: 0x0600297F RID: 10623 RVA: 0x00032BCC File Offset: 0x00030DCC
public GroupScope(Rect position, Texture image)
{
GUI.BeginGroup(position, image);
}
// Token: 0x06002980 RID: 10624 RVA: 0x00032BDC File Offset: 0x00030DDC
public GroupScope(Rect position, GUIContent content)
{
GUI.BeginGroup(position, content);
}
// Token: 0x06002981 RID: 10625 RVA: 0x00032BEC File Offset: 0x00030DEC
public GroupScope(Rect position, GUIStyle style)
{
GUI.BeginGroup(position, style);
}
// Token: 0x06002982 RID: 10626 RVA: 0x00032BFC File Offset: 0x00030DFC
public GroupScope(Rect position, string text, GUIStyle style)
{
GUI.BeginGroup(position, text, style);
}
// Token: 0x06002983 RID: 10627 RVA: 0x00032C10 File Offset: 0x00030E10
public GroupScope(Rect position, Texture image, GUIStyle style)
{
GUI.BeginGroup(position, image, style);
}
// Token: 0x06002984 RID: 10628 RVA: 0x00032C24 File Offset: 0x00030E24
protected override void CloseScope()
{
GUI.EndGroup();
}
}
// Token: 0x0200025C RID: 604
public class ScrollViewScope : GUI.Scope
{
// Token: 0x06002985 RID: 10629 RVA: 0x00032C2C File Offset: 0x00030E2C
public ScrollViewScope(Rect position, Vector2 scrollPosition, Rect viewRect)
{
this.handleScrollWheel = true;
this.scrollPosition = GUI.BeginScrollView(position, scrollPosition, viewRect);
}
// Token: 0x06002986 RID: 10630 RVA: 0x00032C4C File Offset: 0x00030E4C
public ScrollViewScope(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical)
{
this.handleScrollWheel = true;
this.scrollPosition = GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical);
}
// Token: 0x06002987 RID: 10631 RVA: 0x00032C70 File Offset: 0x00030E70
public ScrollViewScope(Rect position, Vector2 scrollPosition, Rect viewRect, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
{
this.handleScrollWheel = true;
this.scrollPosition = GUI.BeginScrollView(position, scrollPosition, viewRect, horizontalScrollbar, verticalScrollbar);
}
// Token: 0x06002988 RID: 10632 RVA: 0x00032C94 File Offset: 0x00030E94
public ScrollViewScope(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar)
{
this.handleScrollWheel = true;
this.scrollPosition = GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar);
}
// Token: 0x06002989 RID: 10633 RVA: 0x00032CBC File Offset: 0x00030EBC
internal ScrollViewScope(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
{
this.handleScrollWheel = true;
this.scrollPosition = GUI.BeginScrollView(position, scrollPosition, viewRect, alwaysShowHorizontal, alwaysShowVertical, horizontalScrollbar, verticalScrollbar, background);
}
// Token: 0x170009B2 RID: 2482
// (get) Token: 0x0600298A RID: 10634 RVA: 0x00032CF0 File Offset: 0x00030EF0
// (set) Token: 0x0600298B RID: 10635 RVA: 0x00032D0C File Offset: 0x00030F0C
public Vector2 scrollPosition { get; private set; }
// Token: 0x170009B3 RID: 2483
// (get) Token: 0x0600298C RID: 10636 RVA: 0x00032D18 File Offset: 0x00030F18
// (set) Token: 0x0600298D RID: 10637 RVA: 0x00032D34 File Offset: 0x00030F34
public bool handleScrollWheel { get; set; }
// Token: 0x0600298E RID: 10638 RVA: 0x00032D40 File Offset: 0x00030F40
protected override void CloseScope()
{
GUI.EndScrollView(this.handleScrollWheel);
}
}
// Token: 0x0200025D RID: 605
public class ClipScope : GUI.Scope
{
// Token: 0x0600298F RID: 10639 RVA: 0x00032D50 File Offset: 0x00030F50
public ClipScope(Rect position)
{
GUI.BeginClip(position);
}
// Token: 0x06002990 RID: 10640 RVA: 0x00032D60 File Offset: 0x00030F60
protected override void CloseScope()
{
GUI.EndClip();
}
}
}
}