wehub-resource-sync
1014 lines
40 KiB
C#
1014 lines
40 KiB
C#
#nullable enable
|
|
using ImGuiNET;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using T3.Editor.Gui.Help;
|
|
using T3.Core.DataTypes.Vector;
|
|
using T3.Core.Operator;
|
|
using T3.Core.Operator.Slots;
|
|
using T3.Core.SystemUi;
|
|
using T3.Editor.App;
|
|
using T3.Editor.Gui.Graph.Dialogs;
|
|
using T3.Editor.Gui.Input;
|
|
using T3.Editor.Gui.Interaction.Variations;
|
|
using T3.Editor.Gui.Interaction.Variations.Model;
|
|
using T3.Editor.Gui.Styling;
|
|
using T3.Editor.Skills.Training;
|
|
using T3.Editor.Gui.Windows.Layouts;
|
|
using T3.Editor.Gui.Windows.Output;
|
|
using T3.Editor.Gui.Windows.RenderExport;
|
|
using T3.Editor.UiModel;
|
|
using T3.Editor.UiModel.Commands;
|
|
using T3.Editor.UiModel.Commands.Graph;
|
|
using T3.Editor.UiModel.InputsAndTypes;
|
|
using T3.Editor.Gui.Windows.Variations;
|
|
using T3.Editor.UiModel.Modification;
|
|
using T3.Editor.UiModel.ProjectHandling;
|
|
using T3.Editor.UiModel.Selection;
|
|
using T3.SystemUi;
|
|
|
|
namespace T3.Editor.Gui.Windows;
|
|
|
|
[HelpUiID("ParameterWindow")]
|
|
internal sealed class ParameterWindow : Window
|
|
{
|
|
public ParameterWindow()
|
|
{
|
|
_instanceCounter++;
|
|
Config.Title = LayoutHandling.ParametersPrefix + _instanceCounter;
|
|
Config.Visible = true;
|
|
MenuTitle = "Parameters";
|
|
WindowFlags = ImGuiWindowFlags.NoScrollbar | ImGuiWindowFlags.NoScrollWithMouse;
|
|
_parameterWindowInstances.Add(this);
|
|
}
|
|
|
|
internal override List<Window> GetInstances()
|
|
{
|
|
return _parameterWindowInstances;
|
|
}
|
|
|
|
protected override void Close()
|
|
{
|
|
_parameterWindowInstances.Remove(this);
|
|
}
|
|
|
|
protected override void AddAnotherInstance()
|
|
{
|
|
// ReSharper disable once ObjectCreationAsStatement
|
|
new ParameterWindow(); // Required to call constructor
|
|
}
|
|
|
|
|
|
protected override void DrawContent()
|
|
{
|
|
// Insert invisible spill over input to catch accidental imgui focus attempts
|
|
{
|
|
ImGui.SetNextItemWidth(2);
|
|
var tmpBuffer = "";
|
|
ImGui.PushStyleColor(ImGuiCol.FrameBg, Color.Transparent.Rgba);
|
|
ImGui.InputText("##imgui workaround", ref tmpBuffer, 1);
|
|
ImGui.PopStyleColor();
|
|
ImGui.SameLine();
|
|
}
|
|
|
|
|
|
if (!NodeSelection.TryGetSelectedInstanceOrInput(out var instance, out var inputUi, out _selectionChanged))
|
|
{
|
|
var nodeSelection = ProjectView.Focused?.NodeSelection;
|
|
var sectionSettingsShown = nodeSelection != null && DrawSettingsForSelectedSections(nodeSelection);
|
|
if (!sectionSettingsShown
|
|
&& VariationHandling.ActivePoolForSnapshots != null
|
|
&& !SkillTraining.IsInPlayMode)
|
|
{
|
|
// Show the active composition's header (name/namespace) too, so entering an
|
|
// operator doesn't require a background click to reveal it.
|
|
var composition = ProjectView.Focused?.CompositionInstance;
|
|
if (composition != null)
|
|
{
|
|
if (DrawSymbolHeader(composition, composition.GetSymbolUi()))
|
|
composition.GetSymbolUi().FlagAsModified();
|
|
}
|
|
|
|
_snapshotControlView.Draw();
|
|
}
|
|
|
|
_lastSelectedInstanceId = Guid.Empty;
|
|
return;
|
|
}
|
|
|
|
if (inputUi != null)
|
|
{
|
|
_viewMode = ViewModes.Settings;
|
|
_parameterSettings.SelectInput(inputUi.Id);
|
|
}
|
|
else if (_selectionChanged)
|
|
{
|
|
_viewMode = ViewModes.Parameters; // Switch back from documentation
|
|
}
|
|
|
|
var symbol = instance.Symbol;
|
|
var parentSymbol = instance.Parent?.Symbol;
|
|
var path = instance.InstancePath;
|
|
|
|
// ReSharper disable once RedundantAssignment
|
|
instance = null; //allow to unload of instance type in case a recompilation occurs
|
|
|
|
// Draw dialogs
|
|
RenameInputDialog.Draw();
|
|
|
|
if (!symbol.TryGetOrCreateInstance(path, parentSymbol, out instance))
|
|
{
|
|
Log.Error($"Failed to get instance for {symbol.Name} with path {string.Join(",", path)}");
|
|
return;
|
|
}
|
|
|
|
// Clicking the graph background selects the composition itself. If it has no inputs
|
|
// to show, the snapshot control view is more useful than an empty parameter list.
|
|
// Handled before the ui-definition lookup, which requires a parent and would bail
|
|
// out for compositions at the home level.
|
|
if (_viewMode == ViewModes.Parameters
|
|
&& IsFocusedComposition(instance)
|
|
&& instance.Inputs.Count == 0
|
|
&& VariationHandling.ActivePoolForSnapshots != null
|
|
&& !SkillTraining.IsInPlayMode)
|
|
{
|
|
if (DrawSymbolHeader(instance, instance.GetSymbolUi()))
|
|
instance.GetSymbolUi().FlagAsModified();
|
|
|
|
_snapshotControlView.Draw();
|
|
return;
|
|
}
|
|
|
|
if (!TryGetUiDefinitions(instance, out var symbolUi, out var symbolChildUi))
|
|
return;
|
|
|
|
var modified = false;
|
|
modified |= DrawSymbolHeader(instance, symbolUi);
|
|
|
|
if (instance.Parent == null)
|
|
{
|
|
CustomComponents.EmptyWindowMessage("Home canvas.");
|
|
return;
|
|
}
|
|
|
|
switch (_viewMode)
|
|
{
|
|
case ViewModes.Parameters:
|
|
DrawChildNameAndFlags(instance);
|
|
DrawParametersArea(instance, symbolChildUi, symbolUi);
|
|
break;
|
|
case ViewModes.Settings:
|
|
modified |= _parameterSettings.DrawContent(symbolUi, ProjectView.Focused!.NodeSelection);
|
|
break;
|
|
}
|
|
|
|
if (modified)
|
|
symbolUi.FlagAsModified();
|
|
}
|
|
|
|
private bool DrawSymbolHeader(Instance op, SymbolUi symbolUi)
|
|
{
|
|
var modified = false;
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, new Vector2(5, 5));
|
|
ImGui.BeginChild("header", new Vector2(0, ImGui.GetFrameHeight() + 5),
|
|
ImGuiChildFlags.AlwaysUseWindowPadding,
|
|
ImGuiWindowFlags.NoScrollbar
|
|
| ImGuiWindowFlags.NoScrollWithMouse
|
|
| ImGuiWindowFlags.NoBackground);
|
|
{
|
|
ImGui.AlignTextToFramePadding();
|
|
// Namespace and symbol
|
|
ImGui.PushFont(Fonts.FontBold);
|
|
|
|
ImGui.TextUnformatted(op.Symbol.Name);
|
|
ImGui.PopFont();
|
|
|
|
ImGui.SameLine();
|
|
ImGui.PushStyleColor(ImGuiCol.Text, UiColors.TextDisabled.Rgba);
|
|
ImGui.TextUnformatted(" in ");
|
|
ImGui.PopStyleColor();
|
|
|
|
/*ImGui.SameLine();
|
|
ImGui.TextUnformatted(op.Symbol.SymbolPackage.RootNamespace);*/ // This is redundant I keep it commented out for now just in case
|
|
|
|
ImGui.SameLine();
|
|
|
|
var namespaceForEdit = op.Symbol.Namespace ?? "";
|
|
|
|
var iconSize = ImGui.GetFrameHeight();
|
|
// 3 icons; the settings and help buttons each nudge themselves +2px right
|
|
var iconBlockWidth = 3 * iconSize + 2 * (ImGui.GetStyle().ItemSpacing.X + 2);
|
|
|
|
ImGui.SetNextItemWidth(ImGui.GetContentRegionAvail().X - iconBlockWidth - ImGui.GetStyle().ItemSpacing.X);
|
|
|
|
var symbol = op.Symbol;
|
|
var package = symbol.SymbolPackage;
|
|
if (!package.IsReadOnly)
|
|
{
|
|
var namespaceModified = InputWithTypeAheadSearch.Draw("##namespace",
|
|
EditorSymbolPackage.AllSymbols
|
|
.Select(i => i.Namespace)
|
|
.Distinct()
|
|
.OrderBy(i => i),
|
|
false,
|
|
ref namespaceForEdit,
|
|
out _,
|
|
out _);
|
|
if (namespaceModified && !string.IsNullOrEmpty(namespaceForEdit) && ImGui.IsKeyPressed(Key.Return.ToImGuiKey()))
|
|
{
|
|
if (!EditableSymbolProject.ChangeSymbolNamespace(symbol, namespaceForEdit, out var reason))
|
|
{
|
|
BlockingWindow.Instance.ShowMessageBox(reason, "Could not rename namespace");
|
|
}
|
|
else
|
|
{
|
|
modified = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ImGui.Text(op.Symbol.Namespace);
|
|
}
|
|
|
|
// Tags...
|
|
{
|
|
ImGui.SameLine();
|
|
// Hard right-align: read-only packages render the namespace as plain text,
|
|
// which ignores the item width set above.
|
|
ImGui.SetCursorPosX(ImGui.GetWindowWidth() - ImGui.GetStyle().WindowPadding.X - iconBlockWidth);
|
|
modified |= DrawSymbolTagsButton(symbolUi);
|
|
}
|
|
|
|
// Settings Modes
|
|
{
|
|
var isSettingsMode = _viewMode == ViewModes.Settings;
|
|
if (_parameterSettings.DrawToggleIcon(symbolUi, ref isSettingsMode))
|
|
{
|
|
_viewMode = isSettingsMode ? ViewModes.Settings : ViewModes.Parameters;
|
|
}
|
|
|
|
CustomComponents.TooltipForLastItem("Click to toggle parameter settings.");
|
|
}
|
|
|
|
// Help icon — shows the doc in the Help window (tooltip while that window is closed).
|
|
OperatorHelp.DrawHelpIcon(symbolUi);
|
|
}
|
|
|
|
ImGui.EndChild();
|
|
ImGui.PopStyleVar();
|
|
return modified;
|
|
}
|
|
|
|
public static bool DrawSymbolTagsButton(SymbolUi symbolUi)
|
|
{
|
|
var modified = false;
|
|
var tagsPopupId = "##Tags" + symbolUi.Symbol.Id;
|
|
var symbolUiTags = symbolUi.Tags;
|
|
var state = GetButtonStatesForSymbolTags(symbolUiTags);
|
|
|
|
if (CustomComponents.IconButton(Icon.Bookmark, Vector2.Zero, state))
|
|
{
|
|
ImGui.OpenPopup(tagsPopupId);
|
|
UpdateTagColors();
|
|
}
|
|
|
|
if (ImGui.IsItemHovered())
|
|
{
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, new Vector2(7,7));
|
|
ImGui.SetNextWindowContentSize(new Vector2(250 * T3Ui.UiScaleFactor, 0));
|
|
if (ImGui.BeginTooltip())
|
|
{
|
|
CustomComponents.HelpText("Symbol Tags affect listing in the Symbol Library and Search widgets.");
|
|
FormInputs.AddVerticalSpace();
|
|
var hadTags = false;
|
|
|
|
foreach (SymbolUi.SymbolTags tagValue in Enum.GetValues(typeof(SymbolUi.SymbolTags)))
|
|
{
|
|
if (!symbolUiTags.HasFlag(tagValue) || tagValue == SymbolUi.SymbolTags.None)
|
|
continue;
|
|
|
|
hadTags = true;
|
|
DrawSymbolTag(symbolUiTags, tagValue);
|
|
ImGui.SameLine(0, 4);
|
|
|
|
if (ImGui.GetContentRegionAvail().X < 100)
|
|
ImGui.NewLine();
|
|
}
|
|
|
|
if (hadTags)
|
|
{
|
|
ImGui.NewLine();
|
|
FormInputs.AddVerticalSpace();
|
|
}
|
|
|
|
CustomComponents.HelpText("Click to Edit...");
|
|
ImGui.EndTooltip();
|
|
}
|
|
ImGui.PopStyleVar();
|
|
}
|
|
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, new Vector2(7,7));
|
|
if (ImGui.BeginPopup(tagsPopupId))
|
|
{
|
|
ImGui.Text("Symbol tags");
|
|
FormInputs.AddVerticalSpace(4 * T3Ui.UiScaleFactor);
|
|
|
|
foreach (SymbolUi.SymbolTags tagValue in Enum.GetValues(typeof(SymbolUi.SymbolTags)))
|
|
{
|
|
if (tagValue == SymbolUi.SymbolTags.None)
|
|
continue;
|
|
|
|
if (DrawSymbolTag(symbolUiTags, tagValue))
|
|
{
|
|
modified = true;
|
|
symbolUi.Tags ^= tagValue;
|
|
}
|
|
}
|
|
|
|
ImGui.EndPopup();
|
|
}
|
|
ImGui.PopStyleVar();
|
|
|
|
return modified;
|
|
}
|
|
|
|
public static CustomComponents.ButtonStates GetButtonStatesForSymbolTags(SymbolUi.SymbolTags symbolUiTags)
|
|
{
|
|
var state = (int)symbolUiTags == 0 ? CustomComponents.ButtonStates.Disabled : CustomComponents.ButtonStates.Emphasized;
|
|
|
|
if ((symbolUiTags & (SymbolUi.SymbolTags.Essential | SymbolUi.SymbolTags.Example | SymbolUi.SymbolTags.Project)) != 0)
|
|
state = CustomComponents.ButtonStates.Activated;
|
|
|
|
if ((symbolUiTags & (SymbolUi.SymbolTags.Obsolete | SymbolUi.SymbolTags.NeedsFix | SymbolUi.SymbolTags.HasUpdate)) != 0)
|
|
state = CustomComponents.ButtonStates.NeedsAttention;
|
|
return state;
|
|
}
|
|
|
|
private static bool DrawSymbolTag(SymbolUi.SymbolTags symbolUiTags, SymbolUi.SymbolTags tagValue)
|
|
{
|
|
ImGui.PushFont(Fonts.FontSmall);
|
|
var isClicked = false;
|
|
var drawList = ImGui.GetWindowDrawList();
|
|
var isActive = symbolUiTags.HasFlag(tagValue);
|
|
var tagName = tagValue.ToString().ToUpperInvariant();
|
|
var size = ImGui.CalcTextSize(tagName);
|
|
var padding = new Vector2(10, 4) * T3Ui.UiScaleFactor;
|
|
if (ImGui.InvisibleButton(tagName, size + padding * 2))
|
|
{
|
|
isClicked = true;
|
|
}
|
|
|
|
if (!_tagColors.TryGetValue(tagValue, out var color))
|
|
color = UiColors.TextMuted;
|
|
|
|
var textColor = isActive ? UiColors.ForegroundFull : ColorVariations.OperatorLabel.Apply(color).Fade(0.4f);
|
|
var bgColor = isActive ? color : ColorVariations.OperatorBackground.Apply(color).Fade(0.2f);
|
|
|
|
var isHovered = ImGui.IsItemHovered();
|
|
var hoverFade = isHovered ? 1 : 0.8f;
|
|
|
|
var pMin = ImGui.GetItemRectMin();
|
|
var pMax = ImGui.GetItemRectMax();
|
|
drawList.AddRectFilled(pMin, pMax, bgColor.Fade(hoverFade), 5);
|
|
drawList.AddText(pMin + padding, textColor.Fade(hoverFade), tagName);
|
|
ImGui.PopFont();
|
|
return isClicked;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is kind of annoying because the definition of the colors might change on theme switching.
|
|
/// So this list would need to be updated on popup open... :-/
|
|
/// </summary>
|
|
private static Dictionary<SymbolUi.SymbolTags, Color> UpdateTagColors()
|
|
{
|
|
return new Dictionary<SymbolUi.SymbolTags, Color>
|
|
{
|
|
{ SymbolUi.SymbolTags.Essential, UiColors.StatusActivated },
|
|
{ SymbolUi.SymbolTags.Example, UiColors.StatusActivated },
|
|
{ SymbolUi.SymbolTags.Project, UiColors.StatusActivated },
|
|
{ SymbolUi.SymbolTags.Obsolete, UiColors.StatusAttention },
|
|
{ SymbolUi.SymbolTags.NeedsFix, UiColors.StatusAttention },
|
|
{ SymbolUi.SymbolTags.HasUpdate, UiColors.StatusAttention },
|
|
};
|
|
}
|
|
|
|
private static Dictionary<SymbolUi.SymbolTags, Color> _tagColors = UpdateTagColors();
|
|
|
|
private void DrawParametersArea(Instance instance, SymbolUi.Child symbolChildUi, SymbolUi symbolUi)
|
|
{
|
|
var compositionSymbolUi = ProjectView.Focused?.InstView?.SymbolUi;
|
|
if (compositionSymbolUi == null)
|
|
return;
|
|
|
|
if (compositionSymbolUi == symbolUi)
|
|
{
|
|
compositionSymbolUi = instance.Parent?.GetSymbolUi();
|
|
if (compositionSymbolUi == null)
|
|
return;
|
|
}
|
|
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, new Vector2(5, 5));
|
|
ImGui.BeginChild("parameters", Vector2.Zero, ImGuiChildFlags.None | ImGuiChildFlags.AlwaysUseWindowPadding, ImGuiWindowFlags.NoBackground);
|
|
|
|
// Scroll back up on operator change
|
|
if (_selectionChanged)
|
|
ImGui.SetScrollY(0);
|
|
|
|
var selectedChildSymbolUi = instance.GetSymbolUi();
|
|
|
|
// Draw parameters
|
|
DrawParameters(instance, selectedChildSymbolUi, symbolChildUi, compositionSymbolUi, false, this);
|
|
FormInputs.AddVerticalSpace(15);
|
|
|
|
|
|
// With the Help window open the summary would only duplicate the doc shown there.
|
|
if (!HelpWindow.IsOpen && OperatorHelp.DrawHelpSummary(symbolUi))
|
|
HelpWindow.ShowTopic(HelpTopic.ForOperator(symbolUi.Symbol.Id), showWindow: true);
|
|
|
|
OperatorHelp.DocumentationRenderer.DrawLinksAndExamples(symbolUi);
|
|
|
|
CustomComponents.HandleDragScrolling(this);
|
|
ImGui.EndChild();
|
|
ImGui.PopStyleVar();
|
|
}
|
|
|
|
private void DrawChildNameAndFlags(Instance op)
|
|
{
|
|
var hideParameters = _parameterSettings.IsActive;
|
|
if (hideParameters)
|
|
return;
|
|
|
|
var symbolChildUi = op.GetChildUi();
|
|
if (symbolChildUi == null)
|
|
return;
|
|
|
|
// Add spacing before
|
|
FormInputs.AddVerticalSpace(3);
|
|
ImGui.Indent(5);
|
|
|
|
var scale = T3Ui.UiScaleFactor;
|
|
var frameHeight = ImGui.GetFrameHeight();
|
|
var spacing = ImGui.GetStyle().ItemSpacing.X;
|
|
var groupGap = 6 * scale;
|
|
|
|
// Icon group: bypass + disable + pin-to-output (like the parameter popup)
|
|
var iconGroupWidth = 3 * frameHeight + 2 * spacing;
|
|
|
|
// Preset selector only when the preset pool tracks this instance
|
|
var presetPool = VariationHandling.ActivePoolForPresets;
|
|
var showPresets = presetPool != null
|
|
&& VariationHandling.ActiveInstanceForPresets is { } presetInstance
|
|
&& presetInstance.SymbolChildId == op.SymbolChildId
|
|
&& presetInstance.Symbol.Id == op.Symbol.Id;
|
|
|
|
// Reserve exact widths so the icon group ends flush right, aligned with the
|
|
// symbol header above (whose child has 5px window padding).
|
|
var availWidth = ImGui.GetContentRegionAvail().X - 5 * scale;
|
|
float nameWidth;
|
|
var dropdownWidth = 0f;
|
|
if (showPresets)
|
|
{
|
|
// name | dropdown | new-preset | gap | icons
|
|
var flexibleWidth = availWidth - (frameHeight + iconGroupWidth + 3 * spacing + groupGap);
|
|
nameWidth = MathF.Max(60 * scale, flexibleWidth * 0.5f);
|
|
dropdownWidth = MathF.Max(60 * scale, flexibleWidth - nameWidth);
|
|
}
|
|
else
|
|
{
|
|
nameWidth = MathF.Max(60 * scale, availWidth - (iconGroupWidth + spacing + groupGap));
|
|
}
|
|
|
|
// SymbolChild Name
|
|
{
|
|
ImGui.SetNextItemWidth(nameWidth);
|
|
|
|
var nameForEdit = symbolChildUi.SymbolChild.Name;
|
|
|
|
ImGui.PushStyleVar(ImGuiStyleVar.FrameRounding, 5);
|
|
if (ImGui.InputText("##symbolChildName", ref nameForEdit, 128))
|
|
{
|
|
if (_symbolChildNameCommand != null)
|
|
_symbolChildNameCommand.NewName = nameForEdit;
|
|
symbolChildUi.SymbolChild.Name = nameForEdit;
|
|
}
|
|
|
|
ImGui.PopStyleVar();
|
|
|
|
if (ImGui.IsItemActivated() && op.Parent != null)
|
|
{
|
|
_symbolChildNameCommand = new ChangeSymbolChildNameCommand(symbolChildUi, op.Parent.Symbol);
|
|
}
|
|
|
|
if (ImGui.IsItemDeactivatedAfterEdit())
|
|
{
|
|
if (_symbolChildNameCommand != null)
|
|
UndoRedoStack.Add(_symbolChildNameCommand);
|
|
|
|
_symbolChildNameCommand = null;
|
|
}
|
|
|
|
// Fake placeholder text
|
|
if (string.IsNullOrEmpty(nameForEdit))
|
|
ImGui.GetWindowDrawList().AddText(ImGui.GetItemRectMin() + new Vector2(5, 4),
|
|
UiColors.TextMuted.Fade(0.5f),
|
|
"Untitled instance");
|
|
}
|
|
|
|
// Preset dropdown + new-preset button
|
|
if (showPresets)
|
|
{
|
|
CollectPresets(presetPool!);
|
|
|
|
// Which preset fully describes the current values? Scanning all presets (instead of only
|
|
// the last-activated one) keeps the indication correct after loading a project or when
|
|
// values were changed from elsewhere.
|
|
var matchingPreset = FindMatchingPreset(presetPool!, op);
|
|
var activePreset = presetPool!.ActiveVariation is { IsPreset: true } activeVariation
|
|
&& _presets.Contains(activeVariation)
|
|
? activeVariation
|
|
: null;
|
|
|
|
string label;
|
|
Color labelColor;
|
|
if (matchingPreset != null)
|
|
{
|
|
label = VariationPicker.GetTitle(matchingPreset);
|
|
labelColor = UiColors.ForegroundFull;
|
|
}
|
|
else if (activePreset != null)
|
|
{
|
|
// Based on a preset but modified — the emphasized new-preset button carries the hint
|
|
label = VariationPicker.GetTitle(activePreset);
|
|
labelColor = UiColors.TextMuted;
|
|
}
|
|
else if (_presets.Count == 0)
|
|
{
|
|
label = "No Presets";
|
|
labelColor = UiColors.TextMuted;
|
|
}
|
|
else
|
|
{
|
|
if (_presets.Count != _lastPresetCountForLabel)
|
|
{
|
|
_lastPresetCountForLabel = _presets.Count;
|
|
_presetCountLabel = _presets.Count == 1 ? "1 Preset" : $"{_presets.Count} Presets";
|
|
}
|
|
|
|
label = _presetCountLabel;
|
|
labelColor = UiColors.Text;
|
|
}
|
|
|
|
ImGui.SameLine();
|
|
|
|
var renamingPreset = TryGetPresetById(_renamingPresetId);
|
|
if (renamingPreset != null)
|
|
{
|
|
// Naming a fresh preset replaces the dropdown; Enter confirms, Escape keeps "untitled".
|
|
ImGui.SetNextItemWidth(dropdownWidth);
|
|
if (_focusPresetRename)
|
|
{
|
|
ImGui.SetKeyboardFocusHere();
|
|
_focusPresetRename = false;
|
|
}
|
|
|
|
ImGui.InputText("##presetName", ref renamingPreset.Title, 256, ImGuiInputTextFlags.AutoSelectAll);
|
|
if (ImGui.IsItemDeactivated())
|
|
{
|
|
_renamingPresetId = Guid.Empty;
|
|
presetPool.SaveVariationsToFile();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_renamingPresetId = Guid.Empty; // The named preset may vanish mid-edit (e.g. undo)
|
|
var selectedPreset = matchingPreset ?? activePreset;
|
|
var chosen = _presetPicker.Draw(_presets, presetPool, op, selectedPreset, label, dropdownWidth,
|
|
out var renameRequested,
|
|
labelColor: labelColor);
|
|
if (chosen != null)
|
|
{
|
|
presetPool.Apply(op, chosen);
|
|
}
|
|
else if (renameRequested && selectedPreset != null)
|
|
{
|
|
_renamingPresetId = selectedPreset.Id;
|
|
_focusPresetRename = true;
|
|
}
|
|
}
|
|
|
|
// Emphasize the new-preset button while there is something worth saving: non-default
|
|
// values that no existing preset describes. Dimmed (but still clickable) otherwise.
|
|
var hasNonDefaults = false;
|
|
foreach (var input in op.Inputs)
|
|
{
|
|
if (input.Input.IsDefault)
|
|
continue;
|
|
|
|
hasNonDefaults = true;
|
|
break;
|
|
}
|
|
|
|
var suggestSaving = hasNonDefaults && matchingPreset == null;
|
|
|
|
ImGui.SameLine();
|
|
if (CustomComponents.IconButton(Icon.Presets, Vector2.Zero,
|
|
suggestSaving
|
|
? CustomComponents.ButtonStates.Emphasized
|
|
: CustomComponents.ButtonStates.Default))
|
|
{
|
|
var newPreset = PresetCanvas.CreatePresetForActivePool();
|
|
if (newPreset != null)
|
|
{
|
|
VariationThumbnailRenderer.RequestRender(presetPool, op, newPreset.Id, toFile: true);
|
|
_renamingPresetId = newPreset.Id;
|
|
_focusPresetRename = true;
|
|
}
|
|
}
|
|
|
|
CustomComponents.TooltipForLastItem(suggestSaving
|
|
? "Parameters don't match any preset — save as new preset"
|
|
: "Create new preset from current values");
|
|
}
|
|
|
|
// Bypass / disable / pin-to-output icons
|
|
ImGui.SameLine(0, spacing + groupGap);
|
|
{
|
|
var bypassable = symbolChildUi.SymbolChild.IsBypassable();
|
|
var isBypassed = symbolChildUi.SymbolChild.IsBypassed;
|
|
if (CustomComponents.ToggleTwoIconsButton(ref isBypassed,
|
|
Icon.OperatorBypassOff,
|
|
Icon.OperatorBypassOn,
|
|
CustomComponents.ButtonStates.NeedsAttention,
|
|
CustomComponents.ButtonStates.Default,
|
|
isEnabled: bypassable)
|
|
&& bypassable)
|
|
{
|
|
UndoRedoStack.AddAndExecute(new ChangeInstanceBypassedCommand(symbolChildUi.SymbolChild, isBypassed));
|
|
}
|
|
|
|
CustomComponents.TooltipForLastItem(!bypassable
|
|
? "This operator cannot be bypassed"
|
|
: isBypassed
|
|
? "Bypassed — click to enable"
|
|
: "Bypass this operator");
|
|
|
|
ImGui.SameLine();
|
|
var isDisabled = symbolChildUi.SymbolChild.IsDisabled;
|
|
if (CustomComponents.ToggleIconButton(ref isDisabled,
|
|
Icon.OperatorDisabled,
|
|
Vector2.Zero,
|
|
CustomComponents.ButtonStates.NeedsAttention))
|
|
{
|
|
UndoRedoStack.AddAndExecute(new ChangeInstanceIsDisabledCommand(symbolChildUi, isDisabled));
|
|
}
|
|
|
|
CustomComponents.TooltipForLastItem(isDisabled ? "Disabled — click to enable" : "Disable this operator");
|
|
// Always drawn (disabled without an output window) so the icon row keeps its layout —
|
|
// skipping it would leave the preceding SameLine dangling and pull the parameter
|
|
// area up onto this line.
|
|
ImGui.SameLine();
|
|
var projectView = ProjectView.Focused;
|
|
var canPin = projectView != null && RenderProcess.OutputWindow != null && projectView.CompositionInstance != null;
|
|
if (!canPin)
|
|
{
|
|
CustomComponents.IconButton(Icon.PlayOutput, Vector2.Zero, CustomComponents.ButtonStates.Disabled);
|
|
CustomComponents.TooltipForLastItem("Pin to output — needs an output window");
|
|
}
|
|
else
|
|
{
|
|
var isPinned = RenderProcess.OutputWindow!.Pinning.TryGetPinnedEvaluationInstance(projectView!.Structure,
|
|
out var pinnedInstance)
|
|
&& pinnedInstance == op;
|
|
|
|
if (CustomComponents.ToggleIconButton(ref isPinned, Icon.PlayOutput, Vector2.Zero))
|
|
{
|
|
if (LayoutHandling.FocusMode)
|
|
{
|
|
var selectedImage = projectView.NodeSelection.GetFirstSelectedInstance();
|
|
if (selectedImage != null)
|
|
{
|
|
projectView.SetBackgroundOutput(selectedImage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NodeActions.PinSelectedToOutputWindow(projectView,
|
|
projectView.NodeSelection,
|
|
projectView.CompositionInstance!,
|
|
true);
|
|
}
|
|
}
|
|
|
|
CustomComponents.TooltipForLastItem(isPinned
|
|
? "Shown as graph background — click to clear"
|
|
: "Show output as graph background");
|
|
}
|
|
}
|
|
|
|
ImGui.Unindent(5);
|
|
}
|
|
|
|
private void CollectPresets(SymbolVariationPool pool)
|
|
{
|
|
_presets.Clear();
|
|
foreach (var variation in pool.AllVariations)
|
|
{
|
|
if (variation.IsPreset)
|
|
_presets.Add(variation);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the preset that exactly describes the instance's current values, with an early-out on
|
|
/// the previous frame's match so the full scan only runs while values are changing.
|
|
/// </summary>
|
|
private Variation? FindMatchingPreset(SymbolVariationPool pool, Instance op)
|
|
{
|
|
var cached = TryGetPresetById(_matchedPresetId);
|
|
if (cached != null && SymbolVariationPool.DoesInstanceMatchPresetExactly(op, cached))
|
|
return cached;
|
|
|
|
_matchedPresetId = Guid.Empty;
|
|
|
|
// Prefer the last-activated preset when several store identical values
|
|
if (pool.ActiveVariation is { IsPreset: true } active
|
|
&& _presets.Contains(active)
|
|
&& SymbolVariationPool.DoesInstanceMatchPresetExactly(op, active))
|
|
{
|
|
_matchedPresetId = active.Id;
|
|
return active;
|
|
}
|
|
|
|
foreach (var preset in _presets)
|
|
{
|
|
if (!SymbolVariationPool.DoesInstanceMatchPresetExactly(op, preset))
|
|
continue;
|
|
|
|
_matchedPresetId = preset.Id;
|
|
return preset;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Variation? TryGetPresetById(Guid id)
|
|
{
|
|
if (id == Guid.Empty)
|
|
return null;
|
|
|
|
foreach (var preset in _presets)
|
|
{
|
|
if (preset.Id == id)
|
|
return preset;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draw all parameters of the selected instance.
|
|
/// The actual implementation is done in <see cref="InputValueUi{T}.DrawParameterEdit"/>
|
|
/// </summary>
|
|
public static void DrawParameters(Instance instance, SymbolUi symbolUi, SymbolUi.Child symbolChildUi,
|
|
SymbolUi compositionSymbolUi, bool hideNonEssentials, ParameterWindow? parameterWindow = null)
|
|
{
|
|
var groupState = GroupState.None;
|
|
|
|
if (instance.Parent == null)
|
|
{
|
|
Log.Warning("can't draw parameters for root instance");
|
|
return;
|
|
}
|
|
|
|
ImGui.PushStyleColor(ImGuiCol.FrameBg, UiColors.BackgroundButton.Rgba);
|
|
ImGui.PushStyleColor(ImGuiCol.FrameBgHovered, UiColors.BackgroundHover.Rgba);
|
|
ImGui.PushID(instance.GetHashCode());
|
|
foreach (var inputSlot in instance.Inputs)
|
|
{
|
|
if (!symbolUi.InputUis.TryGetValue(inputSlot.Id, out var inputUi))
|
|
{
|
|
Log.Warning("Trying to access an non existing input, probably the op instance is not the actual one.");
|
|
continue;
|
|
}
|
|
|
|
InsertGroupsAndPadding(inputUi, ref groupState);
|
|
|
|
ImGui.PushID(inputSlot.Id.GetHashCode());
|
|
var skipIfDefault = groupState == GroupState.InsideClosed;
|
|
|
|
// Draw the actual parameter line implemented
|
|
// in the generic InputValueUi<T>.DrawParameterEdit() method
|
|
|
|
ImGui.PushID(inputSlot.Id.GetHashCode());
|
|
var editState = inputUi.DrawParameterEdit(inputSlot, compositionSymbolUi, symbolChildUi, hideNonEssentials: hideNonEssentials, skipIfDefault);
|
|
ImGui.PopID();
|
|
|
|
HandleInputEditState(instance, inputSlot, editState);
|
|
|
|
if (editState == InputEditStateFlags.ShowOptions && parameterWindow != null)
|
|
{
|
|
parameterWindow._viewMode = ViewModes.Settings;
|
|
parameterWindow._parameterSettings.SelectedInputId = inputUi.Id;
|
|
//NodeSelection.SetSelection(inputUi);
|
|
}
|
|
|
|
ImGui.PopID();
|
|
}
|
|
ImGui.PopID(); // Instance
|
|
|
|
ImGui.PopStyleColor(2);
|
|
|
|
if (groupState == GroupState.InsideOpened)
|
|
FormInputs.EndGroup();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Translates the edit state of a parameter row into in-flight value commands so edits
|
|
/// are undoable. Shared by the regular parameter view and the snapshot control view.
|
|
/// </summary>
|
|
internal static void HandleInputEditState(Instance instance, IInputSlot inputSlot, InputEditStateFlags editState)
|
|
{
|
|
if (instance.Parent == null)
|
|
return;
|
|
|
|
if ((editState & InputEditStateFlags.Started) != 0)
|
|
{
|
|
_inputSlotForActiveCommand = inputSlot;
|
|
_inputValueCommandInFlight =
|
|
new ChangeInputValueCommand(instance.Parent.Symbol, instance.SymbolChildId, inputSlot.Input, inputSlot.Input.Value);
|
|
}
|
|
|
|
if ((editState & InputEditStateFlags.Modified) != 0)
|
|
{
|
|
if (_inputValueCommandInFlight == null || _inputSlotForActiveCommand != inputSlot)
|
|
{
|
|
_inputValueCommandInFlight =
|
|
new ChangeInputValueCommand(instance.Parent.Symbol, instance.SymbolChildId, inputSlot.Input, inputSlot.Input.Value);
|
|
_inputSlotForActiveCommand = inputSlot;
|
|
}
|
|
|
|
_inputValueCommandInFlight.AssignNewValue(inputSlot.Input.Value);
|
|
inputSlot.DirtyFlag.Invalidate();
|
|
}
|
|
|
|
if ((editState & InputEditStateFlags.Finished) != 0)
|
|
{
|
|
if (_inputValueCommandInFlight != null && _inputSlotForActiveCommand == inputSlot)
|
|
{
|
|
UndoRedoStack.Add(_inputValueCommandInFlight);
|
|
}
|
|
|
|
_inputValueCommandInFlight = null;
|
|
}
|
|
}
|
|
|
|
private static void InsertGroupsAndPadding(IInputUi inputUi, ref GroupState groupState)
|
|
{
|
|
// Layouts padding and groups
|
|
if (inputUi.AddPadding)
|
|
FormInputs.AddVerticalSpace(2);
|
|
|
|
if (string.IsNullOrEmpty(inputUi.GroupTitle))
|
|
return;
|
|
|
|
if (groupState == GroupState.InsideOpened)
|
|
FormInputs.EndGroup();
|
|
|
|
if (inputUi.GroupTitle.EndsWith("..."))
|
|
{
|
|
var isOpen = FormInputs.BeginGroup(inputUi.GroupTitle);
|
|
groupState = isOpen ? GroupState.InsideOpened : GroupState.InsideClosed;
|
|
}
|
|
else
|
|
{
|
|
groupState = GroupState.None;
|
|
FormInputs.AddVerticalSpace(5);
|
|
ImGui.PushFont(Fonts.FontSmall);
|
|
ImGui.PushStyleColor(ImGuiCol.Text, UiColors.TextMuted.Rgba);
|
|
ImGui.SetCursorPosX(4);
|
|
ImGui.TextUnformatted(inputUi.GroupTitle.ToUpperInvariant());
|
|
ImGui.PopStyleColor();
|
|
ImGui.PopFont();
|
|
FormInputs.AddVerticalSpace(2);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The selected instance is re-resolved from its path each frame, so compare ids
|
|
/// rather than relying on reference identity with the focused composition.
|
|
/// </summary>
|
|
private static bool IsFocusedComposition(Instance instance)
|
|
{
|
|
var composition = ProjectView.Focused?.CompositionInstance;
|
|
if (composition == null)
|
|
return false;
|
|
|
|
return composition == instance
|
|
|| (composition.Symbol.Id == instance.Symbol.Id && composition.SymbolChildId == instance.SymbolChildId);
|
|
}
|
|
|
|
private static bool TryGetUiDefinitions(Instance instance,
|
|
[NotNullWhen(true)] out SymbolUi? symbolUi,
|
|
[NotNullWhen(true)] out SymbolUi.Child? symbolChildUi)
|
|
{
|
|
symbolUi = instance.GetSymbolUi();
|
|
symbolChildUi = null;
|
|
if (instance.Parent == null)
|
|
return false;
|
|
|
|
var parentUi = instance.Parent.GetSymbolUi();
|
|
symbolChildUi = parentUi.ChildUis[instance.SymbolChildId];
|
|
return true;
|
|
}
|
|
|
|
private static bool DrawSettingsForSelectedSections(NodeSelection nodeSelection)
|
|
{
|
|
var somethingVisible = false;
|
|
// Draw Section settings
|
|
foreach (var section in nodeSelection.GetSelectedNodes<Section>())
|
|
{
|
|
ImGui.PushID(section.Id.GetHashCode());
|
|
ImGui.Indent(10f * T3Ui.UiScaleFactor);
|
|
//ImGui.SetCursorPosX(10f*T3Ui.UiScaleFactor);
|
|
ImGui.PushFont(Fonts.FontLarge);
|
|
ImGui.TextUnformatted("Section settings");
|
|
ImGui.PopFont();
|
|
|
|
FormInputs.AddVerticalSpace();
|
|
ImGui.Separator();
|
|
FormInputs.AddVerticalSpace();
|
|
|
|
ImGui.ColorEdit4("color", ref section.Color.Rgba);
|
|
|
|
FormInputs.AddVerticalSpace();
|
|
CustomComponents.StylizedText("Label:", Fonts.FontBold, UiColors.TextMuted, true);
|
|
ImGui.TextWrapped(section.Label);
|
|
|
|
FormInputs.AddVerticalSpace();
|
|
CustomComponents.StylizedText("Description:", Fonts.FontBold, UiColors.TextMuted.Rgba, true);
|
|
ImGui.TextWrapped(section.Title);
|
|
|
|
FormInputs.AddVerticalSpace();
|
|
ImGui.Separator();
|
|
FormInputs.AddVerticalSpace();
|
|
ImGui.PushStyleColor(ImGuiCol.Text, UiColors.TextMuted.Rgba);
|
|
CustomComponents.IconButton(Icon.Tip,new Vector2(20,20)* T3Ui.UiScaleFactor);
|
|
ImGui.SameLine();
|
|
ImGui.TextWrapped("How to create an Section:\n" +
|
|
"1.Select the operators you want to include in the section.\n" +
|
|
"2.Shift + A to add the section." );
|
|
|
|
FormInputs.AddVerticalSpace();
|
|
CustomComponents.IconButton(Icon.Tip, new Vector2(20, 20) * T3Ui.UiScaleFactor);
|
|
ImGui.SameLine();
|
|
ImGui.TextWrapped("How to edit an Section:\n" +
|
|
"1.Double click on the header.\n" +
|
|
"2.Type in label and/or description");
|
|
ImGui.PopStyleColor();
|
|
ImGui.Unindent();
|
|
ImGui.PopID();
|
|
somethingVisible = true;
|
|
}
|
|
|
|
return somethingVisible;
|
|
}
|
|
|
|
private enum GroupState
|
|
{
|
|
None,
|
|
InsideClosed,
|
|
InsideOpened,
|
|
}
|
|
|
|
private enum ViewModes
|
|
{
|
|
Parameters,
|
|
Settings,
|
|
}
|
|
|
|
private ViewModes _viewMode = ViewModes.Parameters;
|
|
|
|
public static bool IsAnyInstanceVisible()
|
|
{
|
|
return WindowManager.IsAnyInstanceVisible<ParameterWindow>();
|
|
}
|
|
|
|
private static readonly List<Window> _parameterWindowInstances = new();
|
|
private ChangeSymbolChildNameCommand? _symbolChildNameCommand;
|
|
private static ChangeInputValueCommand? _inputValueCommandInFlight;
|
|
private static IInputSlot? _inputSlotForActiveCommand;
|
|
private static int _instanceCounter;
|
|
private Guid _lastSelectedInstanceId;
|
|
private bool _selectionChanged;
|
|
|
|
private readonly ParameterSettings _parameterSettings = new();
|
|
private readonly SnapshotControlView _snapshotControlView = new();
|
|
private readonly VariationPicker _presetPicker = new();
|
|
private readonly List<Variation> _presets = new();
|
|
private int _lastPresetCountForLabel = -1;
|
|
private string _presetCountLabel = "";
|
|
private Guid _matchedPresetId;
|
|
private Guid _renamingPresetId;
|
|
private bool _focusPresetRename;
|
|
public static readonly RenameInputDialog RenameInputDialog = new();
|
|
} |