void BakeCollider()
{
if (m_SpriteShapeController.autoUpdateCollider == false)
{
return;
}
PolygonCollider2D polygonCollider = m_SpriteShapeController.polygonCollider;
if (polygonCollider)
{
Undo.RegisterCompleteObjectUndo(polygonCollider, Undo.GetCurrentGroupName());
EditorUtility.SetDirty(polygonCollider);
m_SpriteShapeController.RefreshSpriteShape();
}
EdgeCollider2D edgeCollider = m_SpriteShapeController.edgeCollider;
if (edgeCollider)
{
Undo.RegisterCompleteObjectUndo(edgeCollider, Undo.GetCurrentGroupName());
EditorUtility.SetDirty(edgeCollider);
m_SpriteShapeController.RefreshSpriteShape();
}
}
override public void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_RecordProperty);
Transform targetTransform = null;
if (m_Ik2D.target)
{
targetTransform = m_Ik2D.target.transform;
}
EditorGUI.BeginChangeCheck();
Transform newTargetTransform = EditorGUILayout.ObjectField(new GUIContent("Target"), targetTransform, typeof(Transform), true) as Transform;
if (EditorGUI.EndChangeCheck())
{
Undo.RegisterCompleteObjectUndo(m_Ik2D, "set target");
if (newTargetTransform && !newTargetTransform.GetComponent <Bone2D>())
{
newTargetTransform = null;
}
if (newTargetTransform != targetTransform)
{
m_TargetTransformProperty.objectReferenceValue = newTargetTransform;
IkUtils.InitializeIk2D(serializedObject);
EditorUpdater.SetDirty("set target");
}
}
/*
* EditorGUI.BeginChangeCheck();
*
* EditorGUILayout.PropertyField(m_TargetTransformProperty);
*
* if(EditorGUI.EndChangeCheck())
* {
* IkUtils.InitializeIk2D(serializedObject);
*
* DoUpdateIK();
* }
*/
EditorGUI.BeginChangeCheck();
EditorGUILayout.Slider(m_WeightProperty, 0f, 1f);
EditorGUILayout.PropertyField(m_RestorePoseProperty);
EditorGUILayout.PropertyField(m_OrientChildProperty);
if (EditorGUI.EndChangeCheck())
{
EditorUpdater.SetDirty(Undo.GetCurrentGroupName());
}
serializedObject.ApplyModifiedProperties();
}
private void RegisterUndoForDirtyManagers()
{
foreach (var manager in m_DirtyManagers)
{
RegisterUndo(manager, Undo.GetCurrentGroupName());
}
}
// prevents selection history flooding
void OnUndoRedoPerformed()
{
// below is a hackish way to catch Undo/Redo from editor
if (!Undo.GetCurrentGroupName().Equals("Selection Change"))
{
return;
}
var evt = Event.current;
if (evt == null)
{
return;
}
if (evt.rawType != EventType.KeyDown)
{
return;
}
switch (evt.keyCode)
{
case KeyCode.Z:
World.NewEntityWith(out UndoEvt _);
_preventSelectionSet = true; // prevent manual Selection set
break;
case KeyCode.Y:
World.NewEntityWith(out RedoEvt _);
_preventSelectionSet = true;
break;
}
}
private void OnUpdate()
{
if (_isLocked)
{
for (int i = 0; i < _transformsToLock.Count; i++)
{
if (_transformsToLock[i].hasChanged)
{
_hasChanged = true;
}
}
if (_hasChanged)
{
for (int i = 0; i < _transformsToLock.Count; i++)
{
//TO-DO: Figure out how to get undo to work with rectTransforms so that this isn't necessary
if (!_transformsToLock[i].GetComponent <RectTransform>())
{
Undo.RecordObject(_transformsToLock[i], Undo.GetCurrentGroupName());
}
UpdateLockedTransforms(i);
_transformsToLock[i].hasChanged = false;
if (!_transformsToLock[i].GetComponent <RectTransform>())
{
Undo.CollapseUndoOperations(Undo.GetCurrentGroup());
}
}
}
}
}
public static SpriteMeshInstance CreateSpriteMeshInstance(SpriteMesh spriteMesh, GameObject gameObject,
bool undo = true)
{
SpriteMeshInstance spriteMeshInstance = null;
if (spriteMesh && gameObject)
{
if (undo)
{
spriteMeshInstance = Undo.AddComponent <SpriteMeshInstance>(gameObject);
}
else
{
spriteMeshInstance = gameObject.AddComponent <SpriteMeshInstance>();
}
spriteMeshInstance.spriteMesh = spriteMesh;
spriteMeshInstance.sharedMaterial = defaultMaterial;
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
List <Bone2D> bones = new List <Bone2D>();
List <string> paths = new List <string>();
Vector4 zero = new Vector4(0f, 0f, 0f, 1f);
foreach (BindInfo bindInfo in spriteMeshData.bindPoses)
{
Matrix4x4 m = spriteMeshInstance.transform.localToWorldMatrix * bindInfo.bindPose.inverse;
GameObject bone = new GameObject(bindInfo.name);
if (undo)
{
Undo.RegisterCreatedObjectUndo(bone, Undo.GetCurrentGroupName());
}
Bone2D boneComponent = bone.AddComponent <Bone2D>();
boneComponent.localLength = bindInfo.boneLength;
bone.transform.position = m * zero;
bone.transform.rotation = m.GetRotation();
bone.transform.parent = gameObject.transform;
bones.Add(boneComponent);
paths.Add(bindInfo.path);
}
BoneUtils.ReconstructHierarchy(bones, paths);
spriteMeshInstance.bones = bones;
SpriteMeshUtils.UpdateRenderer(spriteMeshInstance, undo);
EditorUtility.SetDirty(spriteMeshInstance);
}
return(spriteMeshInstance);
}
void HandleUndoRedo()
{
var groupName = Undo.GetCurrentGroupName();
//Debug.Log(groupName);
if (!string.IsNullOrEmpty(groupName) && groupName.StartsWith("LuaBehaviour"))
{
Reload();
Repaint();
}
}
public void SynchronizeINTERNAL(Transform tform)
{
if (tform != transform)
{
#if UNITY_EDITOR
Undo.RecordObject(transform, Undo.GetCurrentGroupName());
#endif
transform.position = tform.position;
transform.rotation = tform.rotation;
}
synchronize();
}
static void AddToCurrentUndoGroup(Object target)
{
if (target == null)
{
return;
}
var group = Undo.GetCurrentGroup();
var groupName = Undo.GetCurrentGroupName();
EditorUtility.SetDirty(target);
Undo.RegisterCompleteObjectUndo(target, groupName);
Undo.CollapseUndoOperations(group);
}
private void HandleSpriteRectSelectionChange()
{
if ((m_CachedSpriteMeshData == null || HandleUtility.nearestControl == m_RectSelectionTool.controlID || HandleUtility.nearestControl == m_BrushWeightTool.controlID) &&
Event.current.clickCount == 2 && spriteEditor.HandleSpriteSelection())
{
m_CachedSpriteMeshData = selectedSpriteMeshData;
Undo.RegisterCompleteObjectUndo(m_SpriteMeshCache, Undo.GetCurrentGroupName());
m_MeshPreview.SetMeshDirty();
m_SpriteMeshCache.boneSelection.Clear();
m_SpriteMeshCache.selection.Clear();
}
}
void OnSceneGUI()
{
if (Tools.current == Tool.Move)
{
Tools.hidden = true;
float size = HandleUtility.GetHandleSize(m_Bone.transform.position) / 5f;
Quaternion rotation = m_Bone.transform.rotation;
EditorGUI.BeginChangeCheck();
Quaternion cameraRotation = Camera.current.transform.rotation;
if (Event.current.type == EventType.Repaint)
{
Camera.current.transform.rotation = m_Bone.transform.rotation;
}
#if UNITY_5_6_OR_NEWER
Vector3 newPosition = Handles.FreeMoveHandle(m_Bone.transform.position, rotation, size, Vector3.zero,
Handles.RectangleHandleCap);
#else
Vector3 newPosition =
Handles.FreeMoveHandle(m_Bone.transform.position, rotation, size, Vector3.zero, Handles.RectangleCap);
#endif
if (Event.current.type == EventType.Repaint)
{
Camera.current.transform.rotation = cameraRotation;
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m_Bone.transform, "Move");
m_Bone.transform.position = newPosition;
BoneUtils.OrientToChild(m_Bone.parentBone, Event.current.shift, Undo.GetCurrentGroupName(), true);
EditorUtility.SetDirty(m_Bone.transform);
EditorUpdater.SetDirty("Move");
}
}
else
{
Tools.hidden = false;
}
}
static public void DestroyObjectImmediate(Object objectToDestroy)
{
if (objectToDestroy)
{
if (!string.IsNullOrEmpty(Undo.GetCurrentGroupName()))
{
Undo.DestroyObjectImmediate(objectToDestroy);
}
else
{
GameObject.DestroyImmediate(objectToDestroy);
}
}
}
override public void OnInspectorGUI()
{
IkCCD2D ikCCD2D = target as IkCCD2D;
base.OnInspectorGUI();
SerializedProperty numBonesProp = serializedObject.FindProperty("m_NumBones");
SerializedProperty iterationsProp = serializedObject.FindProperty("iterations");
SerializedProperty dampingProp = serializedObject.FindProperty("damping");
Bone2D targetBone = ikCCD2D.target;
serializedObject.Update();
EditorGUI.BeginDisabledGroup(!targetBone);
EditorGUI.BeginChangeCheck();
int chainLength = 0;
if (targetBone)
{
chainLength = targetBone.chainLength;
}
EditorGUILayout.IntSlider(numBonesProp, 0, chainLength);
if (EditorGUI.EndChangeCheck())
{
Undo.RegisterCompleteObjectUndo(ikCCD2D, "Set num bones");
IkUtils.InitializeIk2D(serializedObject);
EditorUpdater.SetDirty("Set num bones");
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(iterationsProp);
EditorGUILayout.PropertyField(dampingProp);
if (EditorGUI.EndChangeCheck())
{
EditorUpdater.SetDirty(Undo.GetCurrentGroupName());
}
serializedObject.ApplyModifiedProperties();
}
void PerformUndo ()
{
Repaint(); //just to make curve undo work.
//modifying curve with a layout writes undo the usual way, and it is displayed in undo stack as "MapMaic Generator Change"
//but somehow GetCurrentGroupName returns the previous action instead, like "Selection Change"
if (!Undo.GetCurrentGroupName().Contains("MapMagic")) return;
foreach (MapMagic.Chunk tw in MapMagic.instance.terrains.Objects()) tw.results.Clear();
MapMagic.instance.gens.ChangeGenerator(null);
if (MapMagic.instance.instantGenerate) { MapMagic.instance.ForceGenerate(); }
Repaint();
}
public void SetPath(UnityObject target)
{
var path = GetPath(target);
path.localToWorldMatrix = Matrix4x4.identity;
var undoName = Undo.GetCurrentGroupName();
var serializedObject = GetSerializedObject(target);
serializedObject.UpdateIfRequiredOrScript();
SetShape(path, serializedObject);
Undo.SetCurrentGroupName(undoName);
}
public static SpriteMeshInstance CreateSpriteMeshInstance(SpriteMesh spriteMesh, bool undo = true)
{
if (spriteMesh)
{
GameObject gameObject = new GameObject(spriteMesh.name);
if (undo)
{
Undo.RegisterCreatedObjectUndo(gameObject, Undo.GetCurrentGroupName());
}
return(CreateSpriteMeshInstance(spriteMesh, gameObject, undo));
}
return(null);
}
public override void OnInspectorGUI()
{
_navTileBanner.Draw();
serializedObject.Update();
// Multi editing not supported as it would not make sense, since every NavLink should be unique.
using (new EditorGUI.DisabledGroupScope(targets.Length > 1))
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(_linkedTileProperty);
if (EditorGUI.EndChangeCheck())
{
// Record the NavLink dictionary for undo.
Undo.RecordObject(NavTileManager.Instance, Undo.GetCurrentGroupName());
TileBase newTile = (TileBase)_linkedTileProperty.objectReferenceValue;
// Callback for the tile change.
if (_linkedTileProperty.objectReferenceValue != Tile.LinkedTile)
{
Tile.OnTileChanged(Tile.LinkedTile, newTile);
}
}
}
// Area index.
EditorHelper.DrawCompressedPopup(_areaIndexProperty, NavTileManager.Instance.AreaManager.AllAreaNames);
// Buttons.
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("View Links"))
{
NavTileWindow.OpenLinksTab();
}
if (GUILayout.Button("Edit Areas"))
{
NavTileWindow.OpenAreasTab();
}
GUILayout.EndHorizontal();
serializedObject.ApplyModifiedProperties();
}
void PerformUndo ()
{
//Repaint(); //just to make curve undo work.
//modifying curve with ascript.layout writes undo the usual way, and it is displayed in undo stack as "MapMaic Generator Change"
//but somehow GetCurrentGroupName returns the previous action instead, like "Selection Change"
if (!Undo.GetCurrentGroupName().Contains("MapMagic")) return;
if (mapMagic!=null)
{
mapMagic.ClearResults();
mapMagic.Generate();
}
Repaint();
}
public override void OnInspectorGUI()
{
ONSPPropagationMaterial material = target as ONSPPropagationMaterial;
EditorGUI.BeginChangeCheck();
Rect r = EditorGUILayout.GetControlRect();
r.width -= rightMargin;
ONSPPropagationMaterial.Preset newPreset =
(ONSPPropagationMaterial.Preset)EditorGUI.EnumPopup(r, "Preset", material.preset);
Event e = Event.current;
EventType type = e.type;
absorption.Draw(e);
scattering.Draw(e);
transmission.Draw(e);
if (EditorGUI.EndChangeCheck())
{
string groupName = Undo.GetCurrentGroupName();
Undo.RegisterCompleteObjectUndo(material, groupName);
if (groupName == "Point Added")
{
Undo.CollapseUndoOperations(Undo.GetCurrentGroup() - 1);
}
if (material.preset != newPreset)
{
material.preset = newPreset;
}
else
{
material.preset = ONSPPropagationMaterial.Preset.Custom;
}
if (Application.isPlaying)
{
material.UploadMaterial();
}
}
}
protected override void OnEnable()
{
if (selections == null)
{
selections = new List <SelectionId>();
}
titleContent.text = WindowName;
base.OnEnable();
editoSerializedObject = new SerializedObject(this);
if (settings == null)
{
settings = new Settings();
}
if (Undo.GetCurrentGroupName() == CommitMessageUndoGroup)
{
Undo.RegisterFullObjectHierarchyUndo(this, "Commit Message Changed");
}
}
void CheckPrefabRevert()
{
// Only want prefab modification in an editor scene.
if (PrefabStageUtility.GetCurrentPrefabStage() != null)
{
return;
}
var undoGroup = Undo.GetCurrentGroupName();
if (!undoGroup.Contains(k_RevertPrefabGroupName))
{
return;
}
// Need to change the name of group to know if we processed the undo group
Undo.SetCurrentGroupName(k_PrefabRevertedGroupName);
prefabInstanceReverted();
}
void synchronize()
{
for (int i = 0; i < ControlPoints.Count; i++)
{
#if UNITY_EDITOR
Undo.RecordObject(ControlPoints[i].transform, Undo.GetCurrentGroupName());
#endif
if (ControlPoints[i].ConnectionSyncPosition)
{
ControlPoints[i].transform.position = transform.position;
}
if (ControlPoints[i].ConnectionSyncRotation)
{
ControlPoints[i].transform.rotation = transform.rotation;
}
ControlPoints[i].RefreshTransform(false);
}
TTransform.FromTransform(transform);
}
public Node AddNode(Vector2 position, Edge edge)
{
Node node = Node.Create(nodes.Count);
nodes.Add(node);
if (edge)
{
edges.Add(Edge.Create(edge.node1, node));
edges.Add(Edge.Create(edge.node2, node));
edges.Remove(edge);
}
m_TexVertices.Add(position);
boneWeights.Add(BoneWeight.Create());
if (blendshapes.Count > 0)
{
List <Vector3> frameVertices = new List <Vector3>(nodes.Count);
Vector3 vertex = ToVertex(position);
foreach (BlendShape blendShape in blendshapes)
{
foreach (BlendShapeFrame frame in blendShape.frames)
{
RegisterObjectUndo(frame, Undo.GetCurrentGroupName());
frameVertices.Clear();
frameVertices.AddRange(frame.vertices);
frameVertices.Add(vertex);
frame.vertices = frameVertices.ToArray();
}
}
}
Triangulate();
m_DirtyVertices = true;
return(node);
}
void onUndoPerformed()
{
if (Undo.GetCurrentGroupName() == "changed clayobject" ||
Undo.GetCurrentGroupName() == "changed clayxel container")
{
this.needsUpdate = true;
}
else if (Undo.GetCurrentGroupName() == "changed clayxel grid")
{
this.init();
}
else if (Undo.GetCurrentGroupName() == "added clayxel solid")
{
this.needsUpdate = true;
}
else if (Undo.GetCurrentGroupName() == "Selection Change")
{
if (UnityEditor.Selection.Contains(this.gameObject))
{
this.init();
}
else
{
if (UnityEditor.Selection.gameObjects.Length > 0)
{
ClayObject clayObj = UnityEditor.Selection.gameObjects[0].GetComponent <ClayObject>();
if (clayObj != null)
{
if (clayObj.getClayxelContainer() == this)
{
this.needsUpdate = true;
}
}
}
}
}
}
public void SetVertex(int index, Vector2 position)
{
if (mode == SpriteMeshEditorWindow.Mode.Mesh)
{
m_TexVertices[index] = position;
m_DirtyVertices = true;
}
else if (mode == SpriteMeshEditorWindow.Mode.Blendshapes)
{
if (!selectedBlendshapeFrame && selectedBlendshape)
{
CreateBlendShapeFrame(selectedBlendshape, blendShapeWeight, Undo.GetCurrentGroupName());
}
if (selectedBlendshapeFrame)
{
selectedBlendshapeFrame.vertices [index] = ToVertex(position);
m_DirtyVertices = true;
}
}
isDirty = true;
}
void SetupReordeableList()
{
m_ReorderableList = new ReorderableList(serializedObject, m_SolversProperty, true, true, true, true);
m_ReorderableList.drawHeaderCallback = (Rect rect) =>
{
GUI.Label(rect, Contents.listHeaderLabel);
};
m_ReorderableList.elementHeightCallback = (int index) =>
{
return(EditorGUIUtility.singleLineHeight + 6);
};
m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isactive, bool isfocused) =>
{
rect.y += 2f;
rect.height = EditorGUIUtility.singleLineHeight;
SerializedProperty element = m_SolversProperty.GetArrayElementAtIndex(index);
SerializedProperty elementData = m_SolverEditorDataProperty.GetArrayElementAtIndex(index);
var width = rect.width;
rect.width = width > Contents.showGizmoPropertyWidth ? Contents.showGizmoPropertyWidth : width;
var showGizmoProperty = elementData.FindPropertyRelative("showGizmo");
showGizmoProperty.boolValue = GUI.Toggle(rect, showGizmoProperty.boolValue, Contents.gizmoVisibilityToolTip, k_Contents.visibilityToggleStyle);
rect.x += rect.width;
width -= rect.width;
rect.width = width > Contents.solverPropertyWidth ? width - Contents.solverColorPropertyWidth : Contents.solverPropertyWidth;
EditorGUI.PropertyField(rect, element, GUIContent.none);
rect.x += rect.width;
width -= 100;
rect.width = width > Contents.solverColorPropertyWidth ? Contents.solverColorPropertyWidth : width;
EditorGUI.PropertyField(rect, elementData.FindPropertyRelative("color"), Contents.gizmoColorTooltip);
};
m_ReorderableList.onAddCallback = (ReorderableList list) =>
{
var menu = new GenericMenu();
foreach (Type type in m_SolverTypes)
{
Solver2DMenuAttribute attribute = Attribute.GetCustomAttribute(type, typeof(Solver2DMenuAttribute)) as Solver2DMenuAttribute;
if (attribute != null)
{
menu.AddItem(new GUIContent(attribute.menuPath), false, OnSelectMenu, type);
}
else
{
menu.AddItem(new GUIContent(type.Name), false, OnSelectMenu, type);
}
}
menu.ShowAsContext();
};
m_ReorderableList.onRemoveCallback = (ReorderableList list) =>
{
Solver2D solver = m_Manager.solvers[list.index];
if (solver)
{
Undo.RegisterCompleteObjectUndo(m_Manager, Undo.GetCurrentGroupName());
m_Manager.RemoveSolver(solver);
GameObject solverGO = solver.gameObject;
if (solverGO.transform.childCount == 0)
{
Undo.DestroyObjectImmediate(solverGO);
}
else
{
Undo.DestroyObjectImmediate(solver);
}
EditorUtility.SetDirty(m_Manager);
}
else
{
ReorderableList.defaultBehaviours.DoRemoveButton(list);
}
};
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_AlwaysUpdateProperty, Contents.alwaysUpdate);
var sprite = m_SpriteSkin.spriteRenderer.sprite;
var spriteChanged = m_CurrentSprite != sprite;
if (m_ReorderableList == null || spriteChanged)
{
m_CurrentSprite = sprite;
InitializeBoneTransformArray();
SetupReorderableList();
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_RootBoneProperty, Contents.rootBoneLabel);
if (EditorGUI.EndChangeCheck())
{
m_NeedsRebind = true;
}
m_BoneFold = EditorGUILayout.Foldout(m_BoneFold, Contents.listHeaderLabel, true);
if (m_BoneFold)
{
EditorGUILayout.Space();
if (!serializedObject.isEditingMultipleObjects)
{
EditorGUI.BeginDisabledGroup(m_SpriteSkin.rootBone == null);
m_ReorderableList.DoLayoutList();
EditorGUI.EndDisabledGroup();
}
}
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
EditorGUI.BeginDisabledGroup(!EnableCreateBones());
DoGenerateBonesButton();
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(!EnableSetBindPose());
DoResetBindPoseButton();
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
#if ENABLE_ANIMATION_PERFORMANCE
m_ExperimentalFold = EditorGUILayout.Foldout(m_ExperimentalFold, Contents.experimental, true);
if (m_ExperimentalFold)
{
EditorGUI.indentLevel++;
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_UseBatching, Contents.useManager);
if (EditorGUI.EndChangeCheck())
{
foreach (var obj in targets)
{
((SpriteSkin)obj).UseBatching(m_UseBatching.boolValue);
}
}
EditorGUI.indentLevel--;
}
#endif
serializedObject.ApplyModifiedProperties();
if (m_NeedsRebind)
{
Rebind();
}
if (spriteChanged && !m_SpriteSkin.ignoreNextSpriteChange)
{
ResetBounds(Undo.GetCurrentGroupName());
m_SpriteSkin.ignoreNextSpriteChange = false;
}
DoValidationWarnings();
}
internal void DoCommit(RepositoryInformation repoInfo, GitDiffWindow window, ref Vector2 commitScroll)
{
var settings = window.GitDiffSettings;
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
if (repoInfo.CurrentOperation == CurrentOperation.Merge)
{
GUILayout.Label(GitGUI.GetTempContent("Merge"), styles.mergeIndicator);
}
window.CommitMaximized = GUILayout.Toggle(window.CommitMaximized, GitGUI.GetTempContent(gitSettings.ReadFromFile ? "File Commit Message: (Read Only)" : "Commit Message: "), styles.commitMessageFoldoud, GUILayout.Width(gitSettings.ReadFromFile ? 210 : 116));
EditorGUI.BeginDisabledGroup(true);
if (!window.CommitMaximized)
{
if (!gitSettings.ReadFromFile)
{
EditorGUI.BeginChangeCheck();
GUI.SetNextControlName("Commit Message Field");
settings.commitMessage = EditorGUILayout.TextArea(settings.commitMessage, GUILayout.Height(EditorGUIUtility.singleLineHeight));
if (EditorGUI.EndChangeCheck())
{
window.SaveCommitMessage();
}
}
else
{
GUILayout.Label(GitGUI.GetTempContent(settings.commitMessageFromFile), GUI.skin.textArea, GUILayout.Height(EditorGUIUtility.singleLineHeight));
}
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
if (window.CommitMaximized)
{
commitScroll = EditorGUILayout.BeginScrollView(commitScroll, GUILayout.Height(window.CalculateCommitTextHeight()));
if (!gitSettings.ReadFromFile)
{
EditorGUI.BeginChangeCheck();
GUI.SetNextControlName("Commit Message Field");
string newCommitMessage = EditorGUILayout.TextArea(settings.commitMessage, GUILayout.ExpandHeight(true));
if (EditorGUI.EndChangeCheck())
{
if ((Event.current.character == ' ' || Event.current.character == '\0') && !(commitMessageLastChar == ' ' || commitMessageLastChar == '\0'))
{
if (Undo.GetCurrentGroupName() == GitDiffWindow.CommitMessageUndoGroup)
{
Undo.IncrementCurrentGroup();
}
}
commitMessageLastChar = Event.current.character;
Undo.RecordObject(window, GitDiffWindow.CommitMessageUndoGroup);
settings.commitMessage = newCommitMessage;
window.SaveCommitMessage();
}
}
else
{
GUILayout.Label(GitGUI.GetTempContent(settings.commitMessageFromFile), GUI.skin.textArea, GUILayout.ExpandHeight(true));
}
EditorGUILayout.EndScrollView();
}
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button(GitGUI.GetTempContent("Commit"), styles.commitButton))
{
GenericMenu commitMenu = new GenericMenu();
BuildCommitMenu(commitMenu, window);
commitMenu.ShowAsContext();
}
GitGUI.StartEnable(!gitSettings.ExternalsType.IsFlagSet(GitSettingsJson.ExternalsTypeEnum.Commit));
settings.emptyCommit = GUILayout.Toggle(settings.emptyCommit, GitGUI.GetTempContent("Empty Commit", "Commit the message only without changes"));
EditorGUI.BeginChangeCheck();
settings.amendCommit = GUILayout.Toggle(settings.amendCommit, GitGUI.GetTempContent("Amend Commit", "Amend previous commit."));
if (EditorGUI.EndChangeCheck())
{
if (settings.amendCommit)
{
window.AmmendCommit();
}
}
settings.prettify = GUILayout.Toggle(settings.prettify, GitGUI.GetTempContent("Prettify", "Prettify the commit message"));
GitGUI.EndEnable();
GUILayout.FlexibleSpace();
if (GitGUI.LinkButtonLayout(gitOverlay.icons.donateSmall, GitGUI.Styles.IconButton))
{
GitLinks.GoTo(GitLinks.Donate);
}
if (GitGUI.LinkButtonLayout(GitGUI.Contents.Help, GitGUI.Styles.IconButton))
{
GitLinks.GoTo(GitLinks.DiffWindowHelp);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
}
public override void OnInspectorGUI()
{
tu.undoRedoEvent = Undo.GetCurrentGroupName();
base.OnInspectorGUI();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Table Properties", labelStyle);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical(box);
EditorGUI.BeginChangeCheck();
int rows = EditorGUILayout.IntSlider(rowLabel, tu.Rows, TableUI.MIN_ROWS, TableUI.MAX_ROWS);
int columns = EditorGUILayout.IntSlider(columnLabel, tu.Columns, TableUI.MIN_COL, TableUI.MAX_COL);
bool header = EditorGUILayout.Toggle(showHeaderLabel, tu.Header);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Table");
tu.Rows = rows;
tu.Columns = columns;
tu.Header = header;
}
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Border Properties", labelStyle);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical(new GUIStyle("box"));
EditorGUI.BeginChangeCheck();
BorderType borderType = (BorderType)EditorGUILayout.EnumPopup(borderTypeLabel, tu.BorderType);
float borderThickness = EditorGUILayout.FloatField(borderThicknessLabel, tu.BorderThickness);
Color borderColor = EditorGUILayout.ColorField(borderColorLabel, tu.BorderColor);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Border");
tu.BorderType = borderType;
tu.BorderThickness = borderThickness;
tu.BorderColor = borderColor;
}
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Text Properties", labelStyle);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical(box);
EditorGUI.indentLevel += 1;
if (tu.Header)
{
headerFoldout = EditorGUILayout.Foldout(headerFoldout, headerFoldoutLabel, true, TMPro.EditorUtilities.TMP_UIStyleManager.boldFoldout);
if (headerFoldout)
{
headerCellPropertiesEditor.OnInspectorGUI();
}
}
bodyFoldout = EditorGUILayout.Foldout(bodyFoldout, bodyFoldoutLabel, true, TMPro.EditorUtilities.TMP_UIStyleManager.boldFoldout);
if (bodyFoldout)
{
bodyCellPropertiesEditor.OnInspectorGUI();
}
EditorGUI.indentLevel -= 1;
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Table Colors", labelStyle);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical(box);
EditorGUI.BeginChangeCheck();
bool striped = EditorGUILayout.Toggle(stripedLabel, tu.Striped);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Color");
tu.Striped = striped;
}
if (tu.Header)
{
EditorGUI.BeginChangeCheck();
Color headerColor = EditorGUILayout.ColorField(headerColorLabel, tu.HeaderColor);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Color");
tu.HeaderColor = headerColor;
}
}
EditorGUI.BeginChangeCheck();
Color mainColor = EditorGUILayout.ColorField(mainColorLabel, tu.MainColor);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Color");
tu.MainColor = mainColor;
}
if (tu.Striped)
{
EditorGUI.BeginChangeCheck();
Color secondaryColor = EditorGUILayout.ColorField(secondaryColorLabel, tu.SecondaryColor);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Color");
tu.SecondaryColor = secondaryColor;
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
Rect r = EditorGUILayout.BeginHorizontal(box);
if (GUILayout.Button("Make all rows the same height", EditorStyles.miniButtonLeft, GUILayout.Height(50f), GUILayout.MinWidth(r.width / 2)))
{
tu.MakeAllRowsTheSameHeight();
}
if (GUILayout.Button("Make all columns the same width", EditorStyles.miniButtonRight, GUILayout.Height(50f), GUILayout.MinWidth(r.width / 2)))
{
tu.MakeAllColumnsTheSameWidth();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
DrawGrid();
}
public void SetupReordeableList()
{
m_ReorderableList = new ReorderableList(serializedObject, m_SolversProperty, true, true, true, true);
m_ReorderableList.drawHeaderCallback = (Rect rect) =>
{
GUI.Label(rect, Contents.listHeaderLabel);
};
m_ReorderableList.elementHeightCallback = (int index) =>
{
return(EditorGUIUtility.singleLineHeight + 6);
};
m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isactive, bool isfocused) =>
{
rect.y += 2f;
rect.height = EditorGUIUtility.singleLineHeight;
SerializedProperty element = m_SolversProperty.GetArrayElementAtIndex(index);
EditorGUI.PropertyField(rect, element, GUIContent.none);
};
m_ReorderableList.onAddCallback = (ReorderableList list) =>
{
var menu = new GenericMenu();
foreach (Type type in m_SolverTypes)
{
Solver2DMenuAttribute attribute = Attribute.GetCustomAttribute(type, typeof(Solver2DMenuAttribute)) as Solver2DMenuAttribute;
if (attribute != null)
{
menu.AddItem(new GUIContent(attribute.menuPath), false, OnSelectMenu, type);
}
else
{
menu.AddItem(new GUIContent(type.Name), false, OnSelectMenu, type);
}
}
menu.ShowAsContext();
};
m_ReorderableList.onRemoveCallback = (ReorderableList list) =>
{
Solver2D solver = m_Manager.solvers[list.index];
if (solver)
{
Undo.RegisterCompleteObjectUndo(m_Manager, Undo.GetCurrentGroupName());
m_Manager.RemoveSolver(solver);
GameObject solverGO = solver.gameObject;
if (solverGO.transform.childCount == 0)
{
Undo.DestroyObjectImmediate(solverGO);
}
else
{
Undo.DestroyObjectImmediate(solver);
}
EditorUtility.SetDirty(m_Manager);
}
else
{
ReorderableList.defaultBehaviours.DoRemoveButton(list);
}
};
}
