1095d6741a
Refactoring Add dispose to content store Added event for source item changed on edit context Added rename to extensions method Added local file path to tab tool tip
491 lines
No EOL
15 KiB
C#
491 lines
No EOL
15 KiB
C#
/*
|
|
Copyright (c) 2018, Lars Brubaker, John Lewin
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
The views and conclusions contained in the software and documentation are those
|
|
of the authors and should not be interpreted as representing official policies,
|
|
either expressed or implied, of the FreeBSD Project.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using JsonPath;
|
|
using MatterHackers.Agg;
|
|
using MatterHackers.Agg.Platform;
|
|
using MatterHackers.Agg.UI;
|
|
using MatterHackers.DataConverters3D;
|
|
using MatterHackers.ImageProcessing;
|
|
using MatterHackers.Localizations;
|
|
using MatterHackers.MatterControl.CustomWidgets;
|
|
using MatterHackers.MatterControl.DesignTools;
|
|
using MatterHackers.MatterControl.DesignTools.Operations;
|
|
using MatterHackers.MatterControl.Library;
|
|
using MatterHackers.MatterControl.SlicerConfiguration;
|
|
using static JsonPath.JsonPathContext.ReflectionValueSystem;
|
|
|
|
namespace MatterHackers.MatterControl.PartPreviewWindow
|
|
{
|
|
public class SelectedObjectPanel : FlowLayoutWidget, IContentStore
|
|
{
|
|
private IObject3D item = new Object3D();
|
|
|
|
private readonly ThemeConfig theme;
|
|
private readonly ISceneContext sceneContext;
|
|
private readonly SectionWidget editorSectionWidget;
|
|
|
|
private readonly GuiWidget editorPanel;
|
|
|
|
private readonly string editorTitle = "Properties".Localize();
|
|
|
|
public SelectedObjectPanel(View3DWidget view3DWidget, ISceneContext sceneContext, ThemeConfig theme)
|
|
: base(FlowDirection.TopToBottom)
|
|
{
|
|
this.HAnchor = HAnchor.Stretch;
|
|
this.VAnchor = VAnchor.Top | VAnchor.Fit;
|
|
this.Padding = 0;
|
|
this.theme = theme;
|
|
this.sceneContext = sceneContext;
|
|
|
|
var toolbar = new LeftClipFlowLayoutWidget()
|
|
{
|
|
BackgroundColor = theme.BackgroundColor,
|
|
Padding = theme.ToolbarPadding,
|
|
HAnchor = HAnchor.Fit,
|
|
VAnchor = VAnchor.Fit
|
|
};
|
|
|
|
scene = sceneContext.Scene;
|
|
|
|
// put in the container for dynamic actions
|
|
primaryActionsPanel = new FlowLayoutWidget()
|
|
{
|
|
HAnchor = HAnchor.Fit,
|
|
VAnchor = VAnchor.Center | VAnchor.Fit
|
|
};
|
|
|
|
toolbar.AddChild(primaryActionsPanel);
|
|
|
|
// put in a make permanent button
|
|
var icon = StaticData.Instance.LoadIcon("apply.png", 16, 16).SetToColor(theme.TextColor).SetPreMultiply();
|
|
applyButton = new IconButton(icon, theme)
|
|
{
|
|
Margin = theme.ButtonSpacing,
|
|
ToolTipText = "Apply".Localize(),
|
|
Enabled = true
|
|
};
|
|
applyButton.Click += (s, e) =>
|
|
{
|
|
if (this.item.CanApply)
|
|
{
|
|
var item = this.item;
|
|
using (new SelectionMaintainer(view3DWidget.Scene))
|
|
{
|
|
item.Apply(view3DWidget.Scene.UndoBuffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// try to ungroup it
|
|
sceneContext.Scene.UngroupSelection();
|
|
}
|
|
};
|
|
toolbar.AddChild(applyButton);
|
|
|
|
// put in a remove button
|
|
cancelButton = new IconButton(StaticData.Instance.LoadIcon("cancel.png", 16, 16).SetToColor(theme.TextColor).SetPreMultiply(), theme)
|
|
{
|
|
Margin = theme.ButtonSpacing,
|
|
ToolTipText = "Cancel".Localize(),
|
|
Enabled = scene.SelectedItem != null
|
|
};
|
|
cancelButton.Click += (s, e) =>
|
|
{
|
|
var item = this.item;
|
|
using (new SelectionMaintainer(view3DWidget.Scene))
|
|
{
|
|
item.Cancel(view3DWidget.Scene.UndoBuffer);
|
|
}
|
|
};
|
|
toolbar.AddChild(cancelButton);
|
|
|
|
overflowButton = new OverflowBar.OverflowMenuButton(theme)
|
|
{
|
|
Enabled = scene.SelectedItem != null,
|
|
};
|
|
overflowButton.ToolTipText = "Selected Object Options".Localize();
|
|
overflowButton.DynamicPopupContent = () =>
|
|
{
|
|
return ApplicationController.Instance.GetModifyMenu(view3DWidget.sceneContext);
|
|
};
|
|
toolbar.AddChild(overflowButton);
|
|
|
|
editorPanel = new FlowLayoutWidget(FlowDirection.TopToBottom)
|
|
{
|
|
HAnchor = HAnchor.Stretch,
|
|
VAnchor = VAnchor.Fit,
|
|
Name = "editorPanel",
|
|
};
|
|
|
|
// Wrap editorPanel with scrollable container
|
|
var scrollableWidget = new ScrollableWidget(true)
|
|
{
|
|
HAnchor = HAnchor.Stretch,
|
|
VAnchor = VAnchor.Stretch
|
|
};
|
|
scrollableWidget.AddChild(editorPanel);
|
|
scrollableWidget.ScrollArea.HAnchor = HAnchor.Stretch;
|
|
|
|
editorSectionWidget = new SectionWidget(editorTitle, scrollableWidget, theme, toolbar, expandingContent: false, defaultExpansion: true, setContentVAnchor: false)
|
|
{
|
|
VAnchor = VAnchor.Stretch
|
|
};
|
|
this.AddChild(editorSectionWidget);
|
|
|
|
this.ContentPanel = editorPanel;
|
|
|
|
// Register listeners
|
|
scene.SelectionChanged += Scene_SelectionChanged;
|
|
}
|
|
|
|
public GuiWidget ContentPanel { get; set; }
|
|
|
|
private readonly JsonPathContext pathGetter = new JsonPathContext();
|
|
private readonly IconButton applyButton;
|
|
private readonly IconButton cancelButton;
|
|
private readonly OverflowBar.OverflowMenuButton overflowButton;
|
|
private readonly InteractiveScene scene;
|
|
private readonly FlowLayoutWidget primaryActionsPanel;
|
|
|
|
public void SetActiveItem(ISceneContext sceneContext)
|
|
{
|
|
var selectedItem = sceneContext?.Scene?.SelectedItem;
|
|
if (this.item == selectedItem)
|
|
{
|
|
return;
|
|
}
|
|
|
|
this.item = selectedItem;
|
|
editorPanel.CloseChildren();
|
|
|
|
// Allow caller to clean up with passing null for selectedItem
|
|
if (item == null)
|
|
{
|
|
editorSectionWidget.Text = editorTitle;
|
|
return;
|
|
}
|
|
|
|
var selectedItemType = selectedItem.GetType();
|
|
|
|
primaryActionsPanel.RemoveChildren();
|
|
|
|
IEnumerable<SceneOperation> primaryActions;
|
|
|
|
if ((primaryActions = SceneOperations.GetPrimaryOperations(selectedItemType)) == null)
|
|
{
|
|
primaryActions = new List<SceneOperation>();
|
|
}
|
|
else
|
|
{
|
|
// Loop over primary actions creating a button for each
|
|
foreach (var primaryAction in primaryActions)
|
|
{
|
|
// TODO: Run visible/enable rules on actions, conditionally add/enable as appropriate
|
|
var button = new IconButton(primaryAction.Icon(theme), theme)
|
|
{
|
|
// Name = namedAction.Title + " Button",
|
|
ToolTipText = primaryAction.Title,
|
|
Margin = theme.ButtonSpacing,
|
|
BackgroundColor = theme.ToolbarButtonBackground,
|
|
HoverColor = theme.ToolbarButtonHover,
|
|
MouseDownColor = theme.ToolbarButtonDown,
|
|
};
|
|
|
|
button.Click += (s, e) =>
|
|
{
|
|
primaryAction.Action.Invoke(sceneContext);
|
|
};
|
|
|
|
primaryActionsPanel.AddChild(button);
|
|
}
|
|
}
|
|
|
|
if (primaryActionsPanel.Children.Any())
|
|
{
|
|
// add in a separator from the apply and cancel buttons
|
|
primaryActionsPanel.AddChild(new ToolbarSeparator(theme.GetBorderColor(50), theme.SeparatorMargin));
|
|
}
|
|
|
|
editorSectionWidget.Text = selectedItem.Name ?? selectedItemType.Name;
|
|
|
|
HashSet<IObject3DEditor> mappedEditors = ApplicationController.Instance.Extensions.GetEditorsForType(selectedItemType);
|
|
|
|
var undoBuffer = sceneContext.Scene.UndoBuffer;
|
|
|
|
if (!(selectedItem.GetType().GetCustomAttributes(typeof(HideMeterialAndColor), true).FirstOrDefault() is HideMeterialAndColor))
|
|
{
|
|
// put in a color edit field
|
|
var colorField = new ColorField(theme, selectedItem.Color);
|
|
colorField.Initialize(0);
|
|
colorField.ValueChanged += (s, e) =>
|
|
{
|
|
if (selectedItem.Color != colorField.Color)
|
|
{
|
|
undoBuffer.AddAndDo(new ChangeColor(selectedItem, colorField.Color));
|
|
}
|
|
};
|
|
|
|
colorField.Content.MouseDown += (s, e) =>
|
|
{
|
|
// make sure the render mode is set to shaded or outline
|
|
if (sceneContext.ViewState.RenderType != RenderOpenGl.RenderTypes.Shaded
|
|
&& sceneContext.ViewState.RenderType != RenderOpenGl.RenderTypes.Outlines)
|
|
{
|
|
// make sure the render mode is set to outline
|
|
sceneContext.ViewState.RenderType = RenderOpenGl.RenderTypes.Outlines;
|
|
}
|
|
};
|
|
|
|
// color row
|
|
var row = new SettingsRow("Color".Localize(), null, colorField.Content, theme);
|
|
|
|
// Special top border style for first item in editor
|
|
row.Border = new BorderDouble(0, 1);
|
|
|
|
editorPanel.AddChild(row);
|
|
|
|
// put in a material edit field
|
|
var materialField = new MaterialIndexField(sceneContext.Printer, theme, selectedItem.MaterialIndex);
|
|
materialField.Initialize(0);
|
|
materialField.ValueChanged += (s, e) =>
|
|
{
|
|
if (selectedItem.MaterialIndex != materialField.MaterialIndex)
|
|
{
|
|
undoBuffer.AddAndDo(new ChangeMaterial(selectedItem, materialField.MaterialIndex));
|
|
}
|
|
};
|
|
|
|
materialField.Content.MouseDown += (s, e) =>
|
|
{
|
|
if (sceneContext.ViewState.RenderType != RenderOpenGl.RenderTypes.Materials)
|
|
{
|
|
// make sure the render mode is set to material
|
|
sceneContext.ViewState.RenderType = RenderOpenGl.RenderTypes.Materials;
|
|
}
|
|
};
|
|
|
|
// material row
|
|
editorPanel.AddChild(
|
|
new SettingsRow("Material".Localize(), null, materialField.Content, theme));
|
|
}
|
|
|
|
var rows = new SafeList<SettingsRow>();
|
|
|
|
// put in the normal editor
|
|
if (selectedItem is ComponentObject3D componentObject
|
|
&& componentObject.Finalized)
|
|
{
|
|
var context = new PPEContext();
|
|
PublicPropertyEditor.AddUnlockLinkIfRequired(selectedItem, editorPanel, theme);
|
|
foreach (var selector in componentObject.SurfacedEditors)
|
|
{
|
|
// if it is a reference to a sheet cell
|
|
if (selector.StartsWith("!"))
|
|
{
|
|
var firtSheet = componentObject.Descendants<SheetObject3D>().FirstOrDefault();
|
|
if (firtSheet != null)
|
|
{
|
|
var cellId = selector.Substring(1);
|
|
var cell = firtSheet.SheetData[cellId];
|
|
if (cell != null)
|
|
{
|
|
// add an editor for the cell
|
|
var field = new DoubleField(theme);
|
|
field.Initialize(0);
|
|
double.TryParse(firtSheet.SheetData.EvaluateExpression(cellId), out double value);
|
|
field.DoubleValue = value;
|
|
field.ClearUndoHistory();
|
|
|
|
field.Content.Descendants<InternalNumberEdit>().First().MaxDecimalsPlaces = 3;
|
|
field.ValueChanged += (s, e) =>
|
|
{
|
|
cell.Expression = field.Value;
|
|
firtSheet.SheetData.Recalculate();
|
|
};
|
|
|
|
var row = new SettingsRow(cell.Name == null ? cellId : cell.Name, null, field.Content, theme);
|
|
|
|
editorPanel.AddChild(row);
|
|
}
|
|
}
|
|
}
|
|
else // parse it as a path to an object
|
|
{
|
|
// Get the named property via reflection
|
|
// Selector example: '$.Children<CylinderObject3D>'
|
|
var match = pathGetter.Select(componentObject, selector).ToList();
|
|
|
|
//// - Add editor row for each
|
|
foreach (var instance in match)
|
|
{
|
|
if (instance is IObject3D object3D)
|
|
{
|
|
if (ApplicationController.Instance.Extensions.GetEditorsForType(object3D.GetType())?.FirstOrDefault() is IObject3DEditor editor)
|
|
{
|
|
ShowObjectEditor((editor, object3D, object3D.Name), selectedItem);
|
|
}
|
|
}
|
|
else if (JsonPathContext.ReflectionValueSystem.LastMemberValue is ReflectionTarget reflectionTarget)
|
|
{
|
|
if (reflectionTarget.Source is IObject3D editedChild)
|
|
{
|
|
context.item = editedChild;
|
|
}
|
|
else
|
|
{
|
|
context.item = item;
|
|
}
|
|
|
|
var editableProperty = new EditableProperty(reflectionTarget.PropertyInfo, reflectionTarget.Source);
|
|
|
|
var editor = PublicPropertyEditor.CreatePropertyEditor(rows, editableProperty, undoBuffer, context, theme);
|
|
if (editor != null)
|
|
{
|
|
editorPanel.AddChild(editor);
|
|
}
|
|
|
|
// Init with custom 'UpdateControls' hooks
|
|
(context.item as IPropertyGridModifier)?.UpdateControls(new PublicPropertyChange(context, "Update_Button"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enforce panel padding
|
|
foreach (var sectionWidget in editorPanel.Descendants<SectionWidget>())
|
|
{
|
|
sectionWidget.Margin = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (item != null
|
|
&& ApplicationController.Instance.Extensions.GetEditorsForType(item.GetType())?.FirstOrDefault() is IObject3DEditor editor)
|
|
{
|
|
ShowObjectEditor((editor, item, item.Name), selectedItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OperationButton : TextButton
|
|
{
|
|
private readonly SceneOperation sceneOperation;
|
|
private readonly ISceneContext sceneContext;
|
|
|
|
public OperationButton(SceneOperation sceneOperation, ISceneContext sceneContext, ThemeConfig theme)
|
|
: base(sceneOperation.Title, theme)
|
|
{
|
|
this.sceneOperation = sceneOperation;
|
|
this.sceneContext = sceneContext;
|
|
}
|
|
|
|
public void EnsureAvailablity()
|
|
{
|
|
this.Enabled = sceneOperation.IsEnabled?.Invoke(sceneContext) != false;
|
|
}
|
|
}
|
|
|
|
private void ShowObjectEditor((IObject3DEditor editor, IObject3D item, string displayName) scopeItem, IObject3D rootSelection)
|
|
{
|
|
var selectedItem = scopeItem.item;
|
|
|
|
var editorWidget = scopeItem.editor.Create(selectedItem, sceneContext.Scene.UndoBuffer, theme);
|
|
editorWidget.HAnchor = HAnchor.Stretch;
|
|
editorWidget.VAnchor = VAnchor.Fit;
|
|
|
|
if (scopeItem.item != rootSelection
|
|
&& scopeItem.editor is PublicPropertyEditor)
|
|
{
|
|
editorWidget.Padding = new BorderDouble(10, 10, 10, 0);
|
|
|
|
// EditOutline section
|
|
var sectionWidget = new SectionWidget(
|
|
scopeItem.displayName ?? "Unknown",
|
|
editorWidget,
|
|
theme);
|
|
|
|
theme.ApplyBoxStyle(sectionWidget, margin: 0);
|
|
|
|
editorWidget = sectionWidget;
|
|
}
|
|
else
|
|
{
|
|
editorWidget.Padding = 0;
|
|
}
|
|
|
|
editorPanel.AddChild(editorWidget);
|
|
}
|
|
|
|
public void Save(ILibraryItem item, IObject3D content)
|
|
{
|
|
this.item.Parent.Children.Modify(children =>
|
|
{
|
|
children.Remove(this.item);
|
|
children.Add(content);
|
|
});
|
|
}
|
|
|
|
public override void OnClosed(EventArgs e)
|
|
{
|
|
// Unregister listeners
|
|
scene.SelectionChanged -= Scene_SelectionChanged;
|
|
|
|
base.OnClosed(e);
|
|
}
|
|
|
|
private void Scene_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
if (editorPanel.Children.FirstOrDefault()?.DescendantsAndSelf<SectionWidget>().FirstOrDefault() is SectionWidget firstSectionWidget)
|
|
{
|
|
firstSectionWidget.Margin = firstSectionWidget.Margin.Clone(top: 0);
|
|
}
|
|
|
|
var selectedItem = scene.SelectedItem;
|
|
|
|
applyButton.Enabled = selectedItem != null
|
|
&& (selectedItem is GroupObject3D
|
|
|| (selectedItem.GetType() == typeof(Object3D) && selectedItem.Children.Any())
|
|
|| selectedItem.CanApply);
|
|
cancelButton.Enabled = selectedItem != null;
|
|
overflowButton.Enabled = selectedItem != null;
|
|
if (selectedItem == null)
|
|
{
|
|
primaryActionsPanel.RemoveChildren();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
} |