private void OnPositioning()
{
lock (guiLock)
{
if (!initialYSet)
{
initialY = this.position.y;
initialYSet = true;
}
var totalWidth = Mathf.Max(minWidth, activatorPosition.width, minOptionWidth + 36, headerWidth + 36);
var totalHeight = Mathf.Min(height, maxHeight);
var position = this.GetDropdownPosition(activatorPosition, new Vector2(totalWidth, totalHeight));
position.y = initialY;
if (!isAnimating && !activeParent.isLoading && activeNode?.option != null && activeNode.option.hasFooter)
{
footerHeight = activeNode.option.GetFooterHeight(activeNode, totalWidth);
position.height += footerHeight;
}
position = LudiqGUIUtility.CropDropdownPosition(position);
minSize = maxSize = position.size;
this.position = position;
}
}
protected override string Label(bool human)
{
if (unit.asset == null)
{
return(base.Label(human));
}
return($"{LudiqGUIUtility.DimString("Set")} {unit.defaultName}");
}
public override string SearchResultLabel(string query)
{
var label = base.SearchResultLabel(query);
label += LudiqGUIUtility.DimString($" (in {PathUtility.NaiveNormalize(folder)})");
return(label);
}
protected override string Label(bool human)
{
if (unit._delegate == null)
{
return("Create Func");
}
return($"{LudiqGUIUtility.DimString("Func")} { unit._delegate?.DisplayName }");
}
public override string SearchResultLabel(string query)
{
var label = base.SearchResultLabel(query);
label += LudiqGUIUtility.DimString($" (in {path.PartBeforeLast('/')})");
return(label);
}
public void OnGUI(SettingsScope scope, string query)
{
if (!PluginContainer.initialized)
{
return;
}
if (editor == null)
{
editor = accessor.CreateInitializedEditor();
}
LudiqGUI.BeginVertical(Styles.background);
EditorGUI.BeginChangeCheck();
using (Inspector.expandTooltip.Override(true))
{
foreach (var item in this[scope].Where(i => i.visible))
{
EditorGUI.BeginChangeCheck();
LudiqGUI.Space(2);
if (!string.IsNullOrEmpty(query))
{
var haystack = Haystack(item);
var matchesSearch = SearchUtility.Matches(query, haystack);
using (LudiqGUI.color.Override(matchesSearch ? Color.white : Color.white.WithAlphaMultiplied(0.5f)))
using (LudiqGUIUtility.LabelHighlight(query))
{
editor.ChildInspector(item).DrawFieldLayout();
}
}
else
{
editor.ChildInspector(item).DrawFieldLayout();
}
LudiqGUI.Space(2);
if (EditorGUI.EndChangeCheck())
{
OnItemChange(item);
}
}
}
if (EditorGUI.EndChangeCheck())
{
Save();
InternalEditorUtility.RepaintAllViews();
}
LudiqGUI.EndVertical();
}
private static void OnUndoRedo()
{
if (PluginContainer.initialized)
{
LudiqGUIUtility.BeginNotActuallyOnGUI();
onUndoRedo?.Invoke();
LudiqGUIUtility.EndNotActuallyOnGUI();
}
}
private static void OnHierarchyChange()
{
if (PluginContainer.initialized)
{
LudiqGUIUtility.BeginNotActuallyOnGUI();
onHierarchyChange?.Invoke();
LudiqGUIUtility.EndNotActuallyOnGUI();
}
}
protected override float GetControlHeight(float width)
{
var height = EditorGUIUtility.singleLineHeight;
if (!Filter(value))
{
height += EditorGUIUtility.standardVerticalSpacing;
height += LudiqGUIUtility.GetHelpBoxHeight(InvalidValueMessage(value), MessageType.Error, width);
}
return(height);
}
public override string SearchResultLabel(string query)
{
var label = base.SearchResultLabel(query);
if (isPrimitive)
{
label += LudiqGUIUtility.DimString($" (in {primitiveFolder})");
}
else if (isAsset)
{
label += LudiqGUIUtility.DimString($" (in {assetFolder})");
}
return(label);
}
internal static void OnSceneGUI(SceneView sceneView)
{
if (PeekPlugin.Configuration.sceneHierarchyShortcut.Check(e))
{
var width = Mathf.Min(sceneView.position.width * 0.9f, 400);
var activator = new Rect
(
(sceneView.position.width - width) / 2,
-1,
width,
0
);
activator = LudiqGUIUtility.GUIToScreenRect(activator);
HierarchyPopup.Show(activator);
e.Use();
}
}
public void Load()
{
storage.Bind(nameof(addComponent), () => LudiqGUIUtility.LoadBuiltinTexture("Toolbar Plus More"));
storage.Bind(nameof(replace), () => resources.LoadIcon("Icons/Replace.png"));
storage.Bind(nameof(more), () => LudiqGUIUtility.LoadBuiltinTexture("LookDevPaneOption", false) ?? LudiqGUIUtility.LoadBuiltinTexture("pane options"));
storage.Bind(nameof(createGameObject), () => LudiqGUIUtility.LoadBuiltinTexture("Toolbar Plus"));
storage.Bind(nameof(createGameObjectOptions), () => LudiqGUIUtility.LoadBuiltinTexture("Toolbar Plus More"));
storage.Bind(nameof(hierarchy), () => LudiqGUIUtility.LoadBuiltinTexture("UnityEditor.SceneHierarchyWindow"));
storage.Bind(nameof(toolbarDragHandle), () => null);
storage.Bind(nameof(script), () => LudiqGUIUtility.LoadBuiltinTexture("cs Script Icon"));
storage.Bind(nameof(pin), () => resources.LoadIcon("Icons/Pin.png"));
storage.Bind(nameof(pinOn), () => resources.LoadIcon("Icons/PinOn.png"));
storage.Bind(nameof(propertyDrawer), () => resources.LoadIcon("Icons/PropertyDrawer.png"));
storage.Bind(nameof(moreOverlay), () => resources.LoadIcon("Icons/MoreOverlay.png"));
storage.Bind(nameof(inconsistentComponents), () => LudiqGUIUtility.LoadBuiltinTexture("FilterByType"));
storage.Bind(nameof(prefab), () => LudiqGUIUtility.LoadBuiltinTexture("Prefab Icon"));
storage.Bind(nameof(prefabOverlayAdded), () => LudiqGUIUtility.LoadBuiltinTexture("PrefabOverlayAdded Icon"));
storage.Bind(nameof(prefabOverlayRemoved), () => LudiqGUIUtility.LoadBuiltinTexture("PrefabOverlayRemoved Icon"));
storage.Bind(nameof(prefabOverlayModified), () => LudiqGUIUtility.LoadBuiltinTexture("PrefabOverlayModified Icon"));
}
internal static void OnSceneGUI(SceneView sceneView)
{
if (e.type == EventType.KeyDown &&
(
(PeekPlugin.Configuration.enableHierarchySpaceShortcut && e.modifiers == EventModifiers.None && e.keyCode == KeyCode.Space) ||
(PeekPlugin.Configuration.enableHierarchyFindShortcut && e.CtrlOrCmd() && e.keyCode == KeyCode.F && !e.shift && !e.alt)))
{
var width = Mathf.Min(sceneView.position.width * 0.9f, 400);
var activator = new Rect
(
(sceneView.position.width - width) / 2,
-1,
width,
0
);
activator = LudiqGUIUtility.GUIToScreenRect(activator);
HierarchyPopup.Show(activator);
e.Use();
}
}
protected override void ContextClickedItem(int id)
{
var item = FindItem(id, rootItem);
if (item is GameObjectItem gameObjectItem)
{
var selection = selectedGameObjects;
GenericMenu.MenuFunction rename = null;
if (selection.Length == 1)
{
rename = () => BeginRename(gameObjectItem);
}
var activatorPosition = LudiqGUIUtility.GUIToScreenRect(GetItemRect(id));
var menu = new GenericMenu();
menu.allowDuplicateNames = true;
GameObjectContextMenu.Fill(selection, menu, activatorPosition, rename);
menu.ShowAsContext();
}
}
public void Load()
{
storage.Bind(nameof(empty), () => EditorTexture.Single(ColorPalette.transparent.GetPixel()));
// Messages
storage.Bind(nameof(informationMessage), () => LudiqGUIUtility.LoadBuiltinTexture("console.infoicon"));
storage.Bind(nameof(questionMessage), () => resources.LoadIcon("Icons/Messages/Question.png"));
storage.Bind(nameof(warningMessage), () => LudiqGUIUtility.LoadBuiltinTexture("console.warnicon"));
storage.Bind(nameof(successMessage), () => resources.LoadIcon("Icons/Messages/Success.png"));
storage.Bind(nameof(errorMessage), () => LudiqGUIUtility.LoadBuiltinTexture("console.erroricon"));
// States
storage.Bind(nameof(warningState), () => LudiqGUIUtility.LoadBuiltinTexture("console.warnicon"));
storage.Bind(nameof(successState), () => resources.LoadIcon("Icons/State/Success.png"));
storage.Bind(nameof(errorState), () => LudiqGUIUtility.LoadBuiltinTexture("console.erroricon"));
storage.Bind(nameof(progress), () => resources.LoadIcon("Icons/State/Progress.png"));
// Versioning
storage.Bind(nameof(upgrade), () => resources.LoadIcon("Icons/Versioning/Upgrade.png"));
storage.Bind(nameof(upToDate), () => resources.LoadIcon("Icons/Versioning/UpToDate.png"));
storage.Bind(nameof(downgrade), () => resources.LoadIcon("Icons/Versioning/Downgrade.png"));
// Windows
storage.Bind(nameof(supportWindow), () => resources.LoadIcon("Icons/Windows/SupportWindow.png"));
storage.Bind(nameof(sidebarAnchorLeft), () => resources.LoadTexture("Icons/Windows/SidebarAnchorLeft.png", CreateTextureOptions.PixelPerfect));
storage.Bind(nameof(sidebarAnchorRight), () => resources.LoadTexture("Icons/Windows/SidebarAnchorRight.png", CreateTextureOptions.PixelPerfect));
// Configuration
storage.Bind(nameof(editorPref), () => resources.LoadTexture("Icons/Configuration/EditorPref.png", new TextureResolution[] { 12, 24 }, CreateTextureOptions.PixelPerfect));
storage.Bind(nameof(projectSetting), () => resources.LoadTexture("Icons/Configuration/ProjectSetting.png", new TextureResolution[] { 12, 24 }, CreateTextureOptions.PixelPerfect));
// Other
storage.Bind(nameof(@null), () => resources.LoadIcon("Icons/Null.png"));
storage.Bind(nameof(generic), () => resources.LoadIcon("Icons/Generic.png"));
storage.Bind(nameof(@new), () => resources.LoadIcon("Icons/New.png"));
storage.Bind(nameof(folder), () => EditorTexture.Single(AssetDatabase.GetCachedIcon("Assets")));
}
private string GetFooterPortLabel(IUnitPort port)
{
string type;
if (port is ValueInput)
{
type = ((IUnitValuePort)port).type.DisplayName() + " Input";
}
else if (port is ValueOutput)
{
type = ((IUnitValuePort)port).type.DisplayName() + " Output";
}
else if (port is ControlInput)
{
type = "Control Input";
}
else if (port is ControlOutput)
{
type = "Control Output";
}
else
{
throw new NotSupportedException();
}
var portDescription = PortDescription(port);
if (!StringUtility.IsNullOrWhiteSpace(portDescription.summary))
{
return($"<b>{portDescription.label}:</b> {portDescription.summary} {LudiqGUIUtility.DimString($"({type})")}");
}
else
{
return($"<b>{portDescription.label}:</b> {LudiqGUIUtility.DimString($"({type})")}");
}
}
private string DimmedKind()
{
return(LudiqGUIUtility.DimString($" ({kind})"));
}
public override void CachePosition()
{
var innerWidth = innerPosition.width;
var innerHeight = innerPosition.height;
var edgeWidth = edgePosition.width;
var edgeHeight = edgePosition.height;
var labelWidth = Styles.label.CalcSize(label).x;
var labelHeight = EditorGUIUtility.singleLineHeight;
sourcePosition = canvas.Widget(transition.source).position;
destinationPosition = canvas.Widget(transition.destination).position;
Vector2 sourceClosestPoint;
Vector2 destinationClosestPoint;
LudiqGUIUtility.ClosestPoints(sourcePosition, destinationPosition, out sourceClosestPoint, out destinationClosestPoint);
if (transition.destination != transition.source)
{
GraphGUI.GetConnectionEdge
(
sourceClosestPoint,
destinationClosestPoint,
out sourceEdge,
out destinationEdge
);
}
else
{
sourceEdge = Edge.Right;
destinationEdge = Edge.Left;
}
sourceEdgeCenter = sourcePosition.GetEdgeCenter(sourceEdge);
destinationEdgeCenter = destinationPosition.GetEdgeCenter(destinationEdge);
siblingStateTransitions.Clear();
var siblingIndex = 0;
// Assign one common axis for transition for all siblings,
// regardless of their inversion. The axis is arbitrarily
// chosen as the axis for the first transition.
var assignedTransitionAxis = false;
var transitionAxis = Vector2.zero;
foreach (var graphTransition in canvas.graph.transitions)
{
var current = transition == graphTransition;
var analog =
transition.source == graphTransition.source &&
transition.destination == graphTransition.destination;
var inverted =
transition.source == graphTransition.destination &&
transition.destination == graphTransition.source;
if (current)
{
siblingIndex = siblingStateTransitions.Count;
}
if (current || analog || inverted)
{
if (!assignedTransitionAxis)
{
var siblingStateTransitionDrawer = canvas.Widget <IStateTransitionWidget>(graphTransition);
transitionAxis = siblingStateTransitionDrawer.sourceEdge.Normal();
assignedTransitionAxis = true;
}
siblingStateTransitions.Add(graphTransition);
}
}
// Fix the edge case where the source and destination perfectly overlap
if (transitionAxis == Vector2.zero)
{
transitionAxis = Vector2.right;
}
// Calculate the spread axis and origin for the set of siblings
var spreadAxis = transitionAxis.Perpendicular1().Abs();
var spreadOrigin = (sourceEdgeCenter + destinationEdgeCenter) / 2;
if (transition.source == transition.destination)
{
spreadAxis = Vector2.up;
spreadOrigin = sourcePosition.GetEdgeCenter(Edge.Bottom) - Vector2.down * 10;
}
if (LudiqCore.Configuration.developerMode && LudiqGraphs.Configuration.debug)
{
Handles.BeginGUI();
Handles.color = Color.yellow;
Handles.DrawLine(spreadOrigin + spreadAxis * -1000, spreadOrigin + spreadAxis * 1000);
Handles.EndGUI();
}
// Calculate the offset of the current sibling by iterating over its predecessors
var spreadOffset = 0f;
var previousSpreadSize = 0f;
for (var i = 0; i <= siblingIndex; i++)
{
var siblingSize = canvas.Widget <IStateTransitionWidget>(siblingStateTransitions[i]).outerPosition.size;
var siblingSizeProjection = GraphGUI.SizeProjection(siblingSize, spreadOrigin, spreadAxis);
spreadOffset += previousSpreadSize / 2 + siblingSizeProjection / 2;
previousSpreadSize = siblingSizeProjection;
}
if (transition.source != transition.destination)
{
// Calculate the total spread size to center the sibling set
var totalSpreadSize = 0f;
for (var i = 0; i < siblingStateTransitions.Count; i++)
{
var siblingSize = canvas.Widget <IStateTransitionWidget>(siblingStateTransitions[i]).outerPosition.size;
var siblingSizeProjection = GraphGUI.SizeProjection(siblingSize, spreadOrigin, spreadAxis);
totalSpreadSize += siblingSizeProjection;
}
spreadOffset -= totalSpreadSize / 2;
}
// Finally, calculate the positions
middle = spreadOrigin + spreadOffset * spreadAxis;
var edgeX = middle.x - edgeWidth / 2;
var edgeY = middle.y - edgeHeight / 2;
_position = new Rect
(
edgeX,
edgeY,
edgeWidth,
edgeHeight
).PixelPerfect();
var innerX = innerPosition.x;
var innerY = innerPosition.y;
_clippingPosition = _position.Encompass(sourceEdgeCenter).Encompass(destinationEdgeCenter);
if (transition.source != transition.destination)
{
entryEdge = destinationEdge;
exitEdge = sourceEdge;
}
else
{
entryEdge = sourceEdge;
exitEdge = destinationEdge;
}
entryEdgeCenter = edgePosition.GetEdgeCenter(entryEdge);
exitEdgeCenter = edgePosition.GetEdgeCenter(exitEdge);
var x = innerX;
iconPosition = new Rect
(
x,
innerY,
Styles.eventIcon.fixedWidth,
Styles.eventIcon.fixedHeight
).PixelPerfect();
x += iconPosition.width;
var clipWidth = innerWidth - (x - innerX);
clipPosition = new Rect
(
x,
edgeY,
clipWidth,
edgeHeight
).PixelPerfect();
labelInnerPosition = new Rect
(
Styles.spaceAroundIcon,
innerY - edgeY,
labelWidth,
labelHeight
).PixelPerfect();
}
internal static void OnSceneGUI(SceneView sceneView)
{
if (!PeekPlugin.Configuration.enableCreator.Display(sceneView.maximized))
{
return;
}
if (SceneViewIntegration.used)
{
return;
}
try
{
Profiler.BeginSample("Peek." + nameof(Creator));
var position = sceneView.GetInnerGuiPosition();
var shortcut = PeekPlugin.Configuration.creatorShortcut;
var preview = shortcut.Preview(e);
var activate = shortcut.Check(e);
if (position.Contains(e.mousePosition) && (preview || activate))
{
Handles.BeginGUI();
var filter = ProbeFilter.@default;
filter.proBuilder = false; // Too slow and useless here anyway
var hit = Probe.Pick(filter, sceneView, e.mousePosition, out var point);
if (preview)
{
var createIndicatorStyle = LudiqStyles.CommandButton(true, true);
var createIndicatorContent = LudiqGUIUtility.TempContent(PeekPlugin.Icons.createGameObjectOptions?[IconSize.Small]);
var createIndicatorSize = createIndicatorStyle.CalcSize(createIndicatorContent);
var createIndicatorPosition = new Rect
(
e.mousePosition.x - (createIndicatorSize.x / 2),
e.mousePosition.y + Styles.indicatorMargin,
createIndicatorSize.x,
createIndicatorSize.y
);
GUI.Label
(
createIndicatorPosition,
createIndicatorContent,
createIndicatorStyle
);
}
if (activate)
{
var activatorPosition = new Rect(e.mousePosition, Vector2.zero);
activatorPosition.width = 220;
activatorPosition = LudiqGUIUtility.GUIToScreenRect(activatorPosition);
// Delay closure allocations
var _hit = hit;
var _point = point;
var _sceneView = sceneView;
LudiqGUI.FuzzyDropdown
(
activatorPosition,
new CreateGameObjectOptionTree(),
null,
(_instance) =>
{
var instance = (GameObject)_instance;
var is2D = instance.GetComponent <RectTransform>() != null ||
instance.GetComponent <SpriteRenderer>() != null;
if (_hit != null)
{
instance.transform.SetParent(_hit.Value.transform.parent, true);
}
instance.transform.position = _point;
if (!is2D && PeekPlugin.Configuration.createOnBounds && instance.CalculateBounds(out var bounds, Space.World, true, false, false, false, false))
{
var difference = _point.y - bounds.min.y;
instance.transform.position += difference * Vector3.up;
}
Selection.activeGameObject = instance;
if (_hit == null && !_sceneView.in2DMode)
{
_sceneView.FrameSelected();
}
}
);
FuzzyWindow.instance.Focus();
e.Use();
}
private GUIContent GetLabelContent(IUnitPort port)
{
string type;
if (port is IUnitControlPort)
{
type = "Flow";
}
else if (port is IUnitValuePort)
{
type = ((IUnitValuePort)port).type.DisplayName();
}
else if (port is IUnitInvalidPort)
{
type = "Invalid";
}
else
{
throw new NotSupportedException();
}
return(new GUIContent(string.Format($"<b>{port.Description<UnitPortDescription>().label}</b> <color=#{ColorPalette.unityForegroundDim.ToHexString()}>: {LudiqGUIUtility.EscapeRichText(type)}</color>")));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (PeekPlugin.Configuration.enableReferenceInspector && !property.hasMultipleDifferentValues && property.objectReferenceValue != null)
{
Rect buttonPosition, fieldPosition;
if (label != GUIContent.none)
{
buttonPosition = new Rect
(
position.x + EditorGUIUtility.labelWidth - IconSize.Small - 1,
position.y,
IconSize.Small,
IconSize.Small
);
fieldPosition = position;
}
else
{
buttonPosition = new Rect
(
position.xMax - IconSize.Small,
position.y + 1,
IconSize.Small,
IconSize.Small
);
fieldPosition = new Rect
(
position.x,
position.y,
position.width - buttonPosition.width - 2,
position.height
);
}
DefaultField(property, label, fieldPosition);
var isActive = PopupWatcher.IsOpenOrJustClosed(lastPopup);
var activatedButton = LudiqGUI.DropdownToggle(buttonPosition, isActive, LudiqGUIUtility.TempContent(PeekPlugin.Icons.propertyDrawer?[IconSize.Small]), GUIStyle.none);
if (activatedButton && !isActive)
{
PopupWatcher.Release(lastPopup);
lastPopup = null;
var targets = new[] { property.objectReferenceValue };
var activatorGuiPosition = buttonPosition;
var activatorScreenPosition = LudiqGUIUtility.GUIToScreenRect(activatorGuiPosition);
if (e.IsContextMouseButton())
{
if (property.objectReferenceValue is GameObject go)
{
GameObjectContextMenu.Open(new[] { go }, activatorScreenPosition);
}
else
{
UnityObjectContextMenu.Open(targets, activatorGuiPosition);
}
}
else
{
lastPopup = EditorPopup.Open(targets, activatorScreenPosition);
PopupWatcher.Watch(lastPopup);
}
}
}
else
{
DefaultField(property, label, position);
}
}
protected override void OnControlGUI(Rect position)
{
EditorGUI.BeginChangeCheck();
var oldValue = (UnityObject)accessor.value;
var fieldPosition = new Rect
(
position.x,
position.y,
position.width,
GetObjectFieldHeight(position.width)
);
UnityObject newValue;
if (fuzzy)
{
newValue = LudiqGUI.ObjectField
(
fieldPosition,
oldValue,
accessor.definedType,
scene,
allowAssetObjects,
typeLabel,
typeIcon,
Filter,
GetOptions,
visualType,
hidableFrame
);
}
else
{
newValue = EditorGUI.ObjectField
(
fieldPosition,
oldValue,
accessor.definedType,
scene != null
);
}
y += EditorGUIUtility.singleLineHeight;
var isValid = Filter(newValue);
if (!isValid)
{
y += EditorGUIUtility.standardVerticalSpacing;
var message = InvalidValueMessage(newValue);
var invalidValueMessagePosition = position.VerticalSection(ref y, LudiqGUIUtility.GetHelpBoxHeight(message, MessageType.Error, position.width));
EditorGUI.HelpBox(invalidValueMessagePosition, message, MessageType.Error);
if (newValue != null && GUI.Button(invalidValueMessagePosition, GUIContent.none, GUIStyle.none))
{
EditorGUIUtility.PingObject(newValue);
}
}
if (EditorGUI.EndChangeCheck())
{
if (isValid)
{
accessor.RecordUndo();
accessor.value = newValue;
}
else
{
Debug.LogWarning(InvalidValueMessage(newValue));
}
}
}
internal static void OnSceneGUI(SceneView sceneView)
{
if (!PeekPlugin.Configuration.enableProbe)
{
return;
}
Profiler.BeginSample("Peek." + nameof(Probe));
try
{
ProgramHighlight(sceneView);
#if PROBUILDER_4_OR_NEWER
PeekProBuilderIntegration.DrawHighlight(proBuilderHighlight);
#endif
var shortcut = PeekPlugin.Configuration.probeShortcut;
// Make sure not to conflict with right-click pan
shortcut.mouseShortcut.checkRelease = true;
shortcut.mouseShortcut.requireStaticRelease = true;
if (shortcut.Check(e) && !SceneViewIntegration.used)
{
var hits = ListPool <ProbeHit> .New();
try
{
PickAllNonAlloc(hits, ProbeFilter.@default, sceneView, e.mousePosition, PeekPlugin.Configuration.probeLimit);
if (hits.Count > 0)
{
var add = e.shift;
var activatorPosition = new Rect(e.mousePosition, Vector2.zero);
activatorPosition.width = 220;
activatorPosition = LudiqGUIUtility.GUIToScreenRect(activatorPosition);
// Note: Had to make FuzzyWindow use OnMouseUp for select here instead
// of OnMouseDown because otherwise escaping the default RectSelection
// behaviour with the event order and DefaultControl ID's was... hell.
LudiqGUI.FuzzyDropdown
(
activatorPosition,
new ProbeOptionTree(hits),
null,
(_hit) =>
{
add |= e?.shift ?? false;
var hit = (ProbeHit)_hit;
hit.Select(add);
}
);
FuzzyWindow.instance.Focus();
GUIUtility.hotControl = 0; // Escape the default RectSelection control
e.Use();
}
}
finally
{
hits.Free();
}
}
}
catch (Exception ex)
{
Debug.LogException(ex);
}
Profiler.EndSample();
}
public float GetHeight(float width)
{
return(LudiqGUIUtility.GetHelpBoxHeight(message, messageType, width));
}
private static Rect ToWindowRect(Rect rect)
{
return(LudiqGUIUtility.Unclip(new Rect(0, 0, rect.width, rect.height)));
}
public float GetWidth()
{
return(LudiqGUIUtility.GetHelpBoxWidth(message, messageType));
}
public static void Draw(bool drawIcon, ToolbarControlProvider toolbarControlProvider, UnityObject target, UnityObject[] targets, bool isSelected, string label, Rect contentPosition, Rect rowPosition, bool hasFocus)
{
var isHovered = rowPosition.Contains(Event.current.mousePosition);
try
{
// TODO: We can hook into AssetsTreeViewGUI.postAssetIconDrawCallback
// to draw under the VCS integration icons
var leftPadding = 0;
if (toolbarControlProvider.window == ToolbarWindow.Project)
{
if (UnityEditor.VersionControl.Provider.enabled)
{
leftPadding = 9;
}
else
{
leftPadding = 2;
}
}
var iconPosition = new Rect
(
contentPosition.x + leftPadding,
contentPosition.y,
IconSize.Small,
IconSize.Small
);
if (drawIcon)
{
if (PeekPlugin.Configuration.enablePreviewIcons && PreviewUtility.TryGetPreview(target, out var preview) && preview != null)
{
GUI.DrawTexture(iconPosition, preview);
if (target is GameObject gameObject && PrefabUtility.IsAddedGameObjectOverride(gameObject))
{
GUI.DrawTexture(iconPosition, PeekPlugin.Icons.prefabOverlayAdded?[(int)iconPosition.width]);
}
}
}
if (isHovered || isSelected)
{
var toolbar = ObjectToolbarProvider.GetToolbar(targets);
if (!toolbar.isValid)
{
return;
}
toolbar.Update();
var toolbarControl = toolbarControlProvider.GetControl(toolbar, target);
toolbarControl.DrawMainToolInTreeView(iconPosition, contentPosition);
var nameWidth = EditorStyles.label.CalcSize(LudiqGUIUtility.TempContent(label)).x;
var maxStripWidth = contentPosition.width - nameWidth - IconSize.Small;
var desiredStripWidth = toolbarControl.GetTreeViewWidth();
var stripWidth = Mathf.Min(desiredStripWidth, maxStripWidth);
float stripX;
switch (PeekPlugin.Configuration.treeViewToolbarAlignment)
{
case TreeViewToolbarAlignment.Left:
stripX = iconPosition.xMax + nameWidth;
break;
case TreeViewToolbarAlignment.Right:
stripX = contentPosition.xMax - stripWidth;
break;
default: throw PeekPlugin.Configuration.treeViewToolbarAlignment.Unexpected();
}
var stripPosition = new Rect
(
stripX,
contentPosition.y,
stripWidth,
contentPosition.height
);
toolbarControl.guiPosition = stripPosition;
toolbarControl.DrawInTreeView(contentPosition, isSelected && hasFocus);
}
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
public SyntaxHighlightingResult FormatTokens(IEnumerable <Token> tokens, int unindentLevel, int maxWidth)
{
var tokensList = tokens.ToList();
var tokenEntries = new Dictionary <Token, SyntaxHighlightingTokenEntry>();
var rawText = new StringBuilder();
var formattedText = new StringBuilder();
var position = new TokenPosition();
var tokenIndex = 0;
var indentationText = " ";
while (tokenIndex < tokensList.Count)
{
var token = tokensList[tokenIndex];
int offsetBefore = rawText.Length;
TokenPosition nextPosition = position;
if (token.Type == TokenType.Indentation)
{
var tokenIndent = token.Indent;
if (tokenIndent != 0)
{
var rawTokenText = token.Text;
var indent = Math.Max(tokenIndent - unindentLevel, 0);
var rawLengthBefore = rawText.Length;
for (int i = 0; i < indent; i++)
{
rawText.Append(indentationText);
formattedText.Append(indentationText);
}
nextPosition = new TokenPosition(position.LineIndex, position.ColumnIndex + (rawText.Length - rawLengthBefore));
}
}
else if (token.Type == TokenType.Newline)
{
nextPosition = new TokenPosition(position.LineIndex + 1, 0);
rawText.Append(Environment.NewLine);
formattedText.Append(Environment.NewLine);
}
else
{
var rawTokenText = token.Text;
if (position.ColumnIndex + rawTokenText.Length >= maxWidth)
{
if (tokenIndex > 0 && tokensList[tokenIndex - 1].Type == TokenType.Indentation)
{
// TODO: if the token still doesn't fit in one line after line breaking and indent, word-wrap or character-wrap the token text.
}
else
{
tokensList.Insert(tokenIndex, new Token(null, TokenType.Newline, Environment.NewLine, token.Indent));
string s = "";
for (int i = 0; i < token.Indent; i++)
{
s += indentationText;
}
tokensList.Insert(tokenIndex + 1, new Token(null, TokenType.Indentation, s, token.Indent));
if (token.Type == TokenType.Space)
{
tokensList.RemoveAt(tokenIndex + 2);
}
continue;
}
}
var escapedTokenText = LudiqGUIUtility.EscapeRichText(rawTokenText);
rawText.Append(rawTokenText);
nextPosition = new TokenPosition(position.LineIndex, position.ColumnIndex + rawTokenText.Length);
if (TryGetRule(token.Type, out var rule))
{
formattedText.Append(rule.StartMarkup).Append(escapedTokenText).Append(rule.EndMarkup);
}
else
{
formattedText.Append(escapedTokenText);
}
}
tokenEntries[token] = new SyntaxHighlightingTokenEntry(offsetBefore, rawText.Length, position, nextPosition);
position = nextPosition;
++tokenIndex;
}
if (formattedText.Length > 0 && formattedText[formattedText.Length - 1] != '\n')
{
rawText.Append(Environment.NewLine);
formattedText.Append(Environment.NewLine);
}
return(new SyntaxHighlightingResult(tokensList, tokenEntries, rawText.ToString(), formattedText.ToString()));
}
protected override string Label(bool human)
{
return($"{LudiqGUIUtility.DimString("Bind")} { unit._delegate?.DisplayName }");
}
protected override float GetInnerHeight(float width)
{
return(LudiqGUIUtility.GetHelpBoxHeight(message, MessageType.Warning, width));
}
