internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
string fieldToDraw,
string labelName,
out VisualElement propertyTextField,
int indentLevel = 0)
{
var propertyRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
propertyTextField = new TextField(512, false, false, ' ')
{
isDelayed = true
};
propertyRow.Add((TextField)propertyTextField,
textField =>
{
textField.value = fieldToDraw;
});
if (valueChangedCallback != null)
{
var textField = (TextField)propertyTextField;
textField.RegisterValueChangedCallback(evt => valueChangedCallback(evt.newValue));
}
propertyRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(propertyRow);
}
public void EditRow(Row row)
{
property = row?.Components.Get <PropertyRow>();
var adapter = adapters[property.Animator.ValueType];
float min, max;
CalcRange(property.Animator, adapter, out min, out max);
MinValue = min;
MaxValue = max;
toolbar.Nodes.Clear();
for (int i = 0; i < adapter.ComponentCount; i++)
{
var color = ColorTheme.Current.TimelineCurveEditor.Curves[i];
var curve = new Curve(property.Animator, i, adapter, color);
Curves.Add(curve);
toolbar.AddNode(new ColorBoxButton(color));
var name = adapter.GetComponentName(i) ?? property.Animator.TargetPropertyPath;
var label = new ThemedSimpleText(name)
{
MinWidth = 60
};
int c = i;
label.AddChangeWatcher(
() => adapter.GetComponentValue(curve.Animator, Document.Current.Animation.Time, c),
v => label.Text = name + ": " + v.ToString("0.00"));
toolbar.AddNode(label);
}
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
int fieldToDraw,
string labelName,
out VisualElement propertyFloatField,
int indentLevel = 0)
{
var integerField = new IntegerField {
value = fieldToDraw
};
if (valueChangedCallback != null)
{
integerField.RegisterValueChangedCallback(evt => { valueChangedCallback(evt.newValue); });
}
propertyFloatField = integerField;
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyFloatField);
defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(defaultRow);
}
VisualElement CreateGUI(AbstractMaterialNode node, InspectableAttribute attribute, out VisualElement propertyVisualElement)
{
VisualElement nodeSettings = new VisualElement();
var nameLabel = PropertyDrawerUtils.CreateLabel($"{node.name} Node", 0, FontStyle.Bold);
nodeSettings.Add(nameLabel);
EnumField precisionField = null;
if (node.canSetPrecision)
{
precisionField = new EnumField(node.precision);
var propertyRow = new PropertyRow(new Label("Precision"));
propertyRow.Add(precisionField, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.precision))
{
return;
}
m_setNodesAsDirtyCallback();
node.owner.owner.RegisterCompleteObjectUndo("Change precision");
node.precision = (Precision)evt.newValue;
node.owner.ValidateGraph();
m_updateNodeViewsCallback();
node.Dirty(ModificationScope.Graph);
});
});
nodeSettings.Add(propertyRow);
}
propertyVisualElement = precisionField;
return(nodeSettings);
}
public static BacksightDataSet.PropertyRow CreatePropertyRow(BacksightDataSet ds)
{
PropertyRow result = ds.Property.NewPropertyRow();
result.Name = result.Value = result.Description = String.Empty;
return(result);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
Gradient fieldToDraw,
string labelName,
out VisualElement propertyGradientField,
int indentLevel = 0)
{
var objectField = new GradientField {
value = fieldToDraw
};
if (valueChangedCallback != null)
{
objectField.RegisterValueChangedCallback(evt => { valueChangedCallback((Gradient)evt.newValue); });
}
propertyGradientField = objectField;
// Any core widgets used by the inspector over and over should come from some kind of factory
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyGradientField);
defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(defaultRow);
}
public void AddLabel(string label, int indentLevel)
{
var propertyRow = new PropertyRow(new Label(label));
ApplyPadding(propertyRow, indentLevel);
this.hierarchy.Add(propertyRow);
}
/// <summary>
/// adds <paramref name="propertyRow"/> to <see cref="PropertyTable"/>'s row list.
/// </summary>
/// <param name="propertyRow"></param>
/// <exception cref="Table.RowColumnCountMismatchException">
/// <seealso cref="Table.AddRow(Row)"/>
/// </exception>
/// <exception cref="RowAndColumnPropertyMismatchException">
/// <seealso cref="assertRowPropertiesMatchColumns(PropertyRow)"/>
/// </exception>
public void AddRow(PropertyRow propertyRow)
{
table.AddRow(propertyRow);
// assert row properties match those of the corresponding table columns
assertRowPropertiesMatchColumns(propertyRow);
}
internal override void AddCustomNodeProperties(VisualElement parentElement, AbstractMaterialNode nodeBase, Action setNodesAsDirtyCallback, Action updateNodeViewsCallback)
{
node = nodeBase as TransformNode;
var normalizeControl = new Toggle();
normalizeControl.value = node.normalize;
normalizePropRow = new PropertyRow(new Label("Normalize Output"));
normalizePropRow.Add(normalizeControl, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.normalize))
{
return;
}
setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo("Change normalize");
node.normalize = evt.newValue;
updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
});
parentElement.Add(normalizePropRow);
UpdateVisibility();
node.RegisterCallback(OnNodeModified);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
ToggleData fieldToDraw,
string labelName,
out VisualElement propertyToggle,
int indentLevel = 0)
{
var row = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
// Create and assign toggle as out variable here so that callers can also do additional work with enabling/disabling if needed
propertyToggle = new Toggle();
row.Add((Toggle)propertyToggle, (toggle) =>
{
toggle.value = fieldToDraw.isOn;
});
if (valueChangedCallback != null)
{
var toggle = (Toggle)propertyToggle;
toggle.OnToggleChanged(evt => valueChangedCallback(new ToggleData(evt.newValue)));
}
row.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(row);
}
void ReadProperties()
{
if (!m_tHeap.HasTable(PropertyTable.RId))
{
m_properties = new PropertyDefinition [0];
return;
}
PropertyTable propsTable = m_tableReader.GetPropertyTable();
PropertyMapTable pmapTable = m_tableReader.GetPropertyMapTable();
m_properties = new PropertyDefinition [propsTable.Rows.Count];
for (int i = 0; i < pmapTable.Rows.Count; i++)
{
PropertyMapRow pmapRow = pmapTable [i];
if (pmapRow.Parent == 0)
{
continue;
}
TypeDefinition owner = GetTypeDefAt(pmapRow.Parent);
GenericContext context = new GenericContext(owner);
int start = (int)pmapRow.PropertyList, last = propsTable.Rows.Count + 1, end;
if (i < pmapTable.Rows.Count - 1)
{
end = (int)pmapTable [i + 1].PropertyList;
}
else
{
end = last;
}
if (end > last)
{
end = last;
}
for (int j = start; j < end; j++)
{
PropertyRow prow = propsTable [j - 1];
PropertySig psig = m_sigReader.GetPropSig(prow.Type);
PropertyDefinition pdef = new PropertyDefinition(
m_root.Streams.StringsHeap [prow.Name],
GetTypeRefFromSig(psig.Type, context),
prow.Flags);
pdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Property, j - 1);
pdef.PropertyType = GetModifierType(psig.CustomMods, pdef.PropertyType);
if (!IsDeleted(pdef))
{
owner.Properties.Add(pdef);
}
m_properties [j - 1] = pdef;
}
}
}
/// <summary>
/// Parse the RopGetReceiveFolderTableResponse structure.
/// </summary>
/// <param name="s">An stream containing RopGetReceiveFolderTableResponse structure.</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.RopId = (RopIdType)ReadByte();
this.InputHandleIndex = ReadByte();
List <PropertyRow> TmpRows = new List <PropertyRow>();
HelpMethod help = new HelpMethod();
this.ReturnValue = help.FormatErrorCode(ReadUint());
if ((ErrorCodes)ReturnValue == ErrorCodes.Success)
{
this.RowCount = ReadUint();
for (int i = 0; i < this.RowCount; i++)
{
// PidTagMessageClass is defined as PtypString8 due to Open Specification said all characters in this property MUST be from the
// ASCII characters 0x20 through 0x7F.
PropertyTag[] Properties_GetReceiveFolderTable = new PropertyTag[3]
{
new PropertyTag(PropertyDataType.PtypInteger64, PidTagPropertyEnum.PidTagFolderId),
new PropertyTag(PropertyDataType.PtypString8, PidTagPropertyEnum.PidTagMessageClass),
new PropertyTag(PropertyDataType.PtypTime, PidTagPropertyEnum.PidTagLastModificationTime)
};
PropertyRow ProRow = new PropertyRow(Properties_GetReceiveFolderTable);
ProRow.Parse(s);
TmpRows.Add(ProRow);
}
this.Rows = TmpRows.ToArray();
}
}
internal static void AddCustomEnumProperty <T>(
VisualElement parentElement, AbstractMaterialNode node,
Action setNodesAsDirtyCallback, Action updateNodeViewsCallback,
String label,
String undoLabel,
Func <T> GetterFn,
Action <T> SetterFn) where T : System.Enum, IConvertible
{
var fieldObj = new EnumField(GetterFn());
//fieldObj.value = ;
var propertyRow = new PropertyRow(new Label(label));
propertyRow.Add(fieldObj, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(GetterFn()))
{
return;
}
setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo(undoLabel);
SetterFn((T)evt.newValue);
node.owner.ValidateGraph();
updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
});
if (node is Serialization.MultiJsonInternal.UnknownNodeType)
{
fieldObj.SetEnabled(false);
}
parentElement.Add(propertyRow);
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new PropertyRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += PropertyRow.LogicalSize;
}
}
VisualElement CreateGUI(AbstractMaterialNode node, InspectableAttribute attribute, out VisualElement propertyVisualElement)
{
VisualElement nodeSettings = new VisualElement();
var nameLabel = PropertyDrawerUtils.CreateLabel($"{node.name} Node", 0, FontStyle.Bold);
nodeSettings.Add(nameLabel);
if (node.sgVersion < node.latestVersion)
{
var help = HelpBoxRow.TryGetDeprecatedHelpBoxRow($"{node.name} Node", () =>
{
m_setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo($"Update {node.name} Node");
node.ChangeVersion(node.latestVersion);
inspectorUpdateDelegate?.Invoke();
m_updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
if (help != null)
{
nodeSettings.Insert(0, help);
}
}
EnumField precisionField = null;
if (node.canSetPrecision)
{
precisionField = new EnumField(node.precision);
var propertyRow = new PropertyRow(new Label("Precision"));
propertyRow.Add(precisionField, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.precision))
{
return;
}
m_setNodesAsDirtyCallback();
node.owner.owner.RegisterCompleteObjectUndo("Change precision");
node.precision = (Precision)evt.newValue;
node.owner.ValidateGraph();
m_updateNodeViewsCallback();
node.Dirty(ModificationScope.Graph);
});
});
if (node is Serialization.MultiJsonInternal.UnknownNodeType)
{
precisionField.SetEnabled(false);
}
nodeSettings.Add(propertyRow);
}
propertyVisualElement = precisionField;
return(nodeSettings);
}
private void ShowHotkeyWindow(Hotkey hotkey, LabelProperty prop, int kbindex)
{
PropertyRow row = (PropertyRow)prop.Parent;
var wnd = new RebindHotkeyWindow(_canvas, row.Label.ToString());
wnd.KeybindChanged += (x, newbind) =>
{
TryNewKeybind(hotkey, newbind, kbindex);
};
wnd.ShowCentered();
}
/// <summary>
/// Reads the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="result">The result.</param>
public void Read(TokenTypes token, out PropertyRow result)
{
if ((token & TokenTypes.TableMask) != TokenTypes.Property)
{
throw new ArgumentException("Invalid token type for PropertyRow.", "token");
}
using (BinaryReader reader = CreateReaderForToken(token))
{
result = new PropertyRow((PropertyAttributes)reader.ReadUInt16(), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.BlobHeap));
}
}
/// <summary>
/// asserts that <paramref name="propertyRow"/>'s column properties match
/// <see cref="PropertyTable"/>'s column properties.
/// </summary>
/// <param name="propertyRow"></param>
/// <exception cref="RowAndColumnPropertyMismatchException">
/// thrown if <paramref name="propertyRow"/>'s column properties did not match
/// <see cref="PropertyTable"/>'s column properties.
/// </exception>
private void assertRowPropertiesMatchColumns(PropertyRow propertyRow)
{
for (int i = 0; i < propertyRow.Properties.Length; i++)
{
Property currentColumnProperty = columnProperties[i];
Property currentRowProperty = propertyRow.Properties[i];
if (currentColumnProperty != currentRowProperty)
{
throw new RowAndColumnPropertyMismatchException(i);
}
}
}
public void AddProperty <T>(string label, int indentLevel, BaseField <T> field, EventCallback <ChangeEvent <T> > evt)
{
if (field is INotifyValueChanged <T> notifyValueChanged)
{
notifyValueChanged.RegisterValueChangedCallback(evt);
}
var propertyRow = new PropertyRow(new Label(label));
ApplyPadding(propertyRow, indentLevel);
propertyRow.Add(field);
this.hierarchy.Add(propertyRow);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
PropertyRow other = obj as PropertyRow;
return(other != null &&
base.Equals(other) &&
Enumerable.SequenceEqual(this.properties, other.properties));
}
public void Execute()
{
// Create the special properties.
if (null != this.WixPropertyTable)
{
// Create lists of the properties that contribute to the special lists of properties.
SortedSet <string> adminProperties = new SortedSet <string>();
SortedSet <string> secureProperties = new SortedSet <string>();
SortedSet <string> hiddenProperties = new SortedSet <string>();
foreach (WixPropertyRow wixPropertyRow in this.WixPropertyTable.Rows)
{
if (wixPropertyRow.Admin)
{
adminProperties.Add(wixPropertyRow.Id);
}
if (wixPropertyRow.Hidden)
{
hiddenProperties.Add(wixPropertyRow.Id);
}
if (wixPropertyRow.Secure)
{
secureProperties.Add(wixPropertyRow.Id);
}
}
Table propertyTable = this.PropertyTable;
if (0 < adminProperties.Count)
{
PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
row.Property = "AdminProperties";
row.Value = String.Join(";", adminProperties);
}
if (0 < secureProperties.Count)
{
PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
row.Property = "SecureCustomProperties";
row.Value = String.Join(";", secureProperties);
}
if (0 < hiddenProperties.Count)
{
PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
row.Property = "MsiHiddenProperties";
row.Value = String.Join(";", hiddenProperties);
}
}
}
internal override void AddCustomNodeProperties(VisualElement parentElement, AbstractMaterialNode nodeBase, Action setNodesAsDirtyCallback, Action updateNodeViewsCallback)
{
node = nodeBase as TriplanarNode;
var previewField = new EnumField(node.inputSpace);
inputPropRow = new PropertyRow(new Label("Input Space"));
inputPropRow.Add(previewField, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.inputSpace))
{
return;
}
setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo("Change normal input space");
node.inputSpace = (CoordinateSpace)evt.newValue;
updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
});
parentElement.Add(inputPropRow);
previewField = new EnumField(node.normalOutputSpace);
normalOutputPropRow = new PropertyRow(new Label("Normal Output Space"));
normalOutputPropRow.Add(previewField, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.normalOutputSpace))
{
return;
}
setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo("Change normal output space");
node.normalOutputSpace = (CoordinateSpace)evt.newValue;
updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
});
parentElement.Add(normalOutputPropRow);
UpdateVisibility();
node.RegisterCallback(OnNodeModified);
}
public PropertiesTest(ControlBase parent)
: base(parent)
{
{
Properties props = new Properties(this);
props.Dock = Dock.Top;
props.Width = 300;
props.ValueChanged += OnChanged;
{
{
PropertyRow pRow = props.Add("First Name");
}
props.Add("Middle Name");
props.Add("Last Name");
}
}
{
PropertyTree ptree = new PropertyTree(this);
ptree.Dock = Dock.Top;
ptree.Width = 300;
ptree.AutoSizeToContent = true;
{
Properties props = ptree.Add("Item One");
props.ValueChanged += OnChanged;
props.Add("Middle Name");
props.Add("Last Name");
props.Add("Four");
}
{
Properties props = ptree.Add("Item Two");
props.ValueChanged += OnChanged;
props.Add("More Items");
props.Add("Bacon", new CheckProperty(props), "1");
props.Add("To Fill");
props.Add("Color", new ColorProperty(props), "255 0 0");
props.Add("Out Here");
}
ptree.ExpandAll();
}
}
private void populate_property_rows(ObservableCollection <PropertyRow> prop_rows, List <string> path, CharDictProperty prop)
{
List <string> prop_names = new List <string>(prop.value.Keys);
prop_names.Sort();
foreach (string prop_name in prop_names)
{
List <string> row_path = new List <string>(path);
row_path.Add(prop_name);
PropertyRow row = null;
if (prop.value[prop_name] is CharTextProperty text_prop)
{
row = new PropertyRow(prop_name, row_path, text_prop.value);
}
else if (prop.value[prop_name] is CharNumProperty num_prop)
{
row = new PropertyRow(prop_name, row_path, num_prop.value.ToString());
}
else if (prop.value[prop_name] is CharSetProperty set_prop)
{
row = new PropertyRow(prop_name, row_path);
List <string> members = new List <string>(set_prop.value);
members.Sort();
foreach (string member in members)
{
List <string> member_path = new List <string>(row_path);
member_path.Add(member);
row.children.Add(new PropertyRow(member, member_path));
}
}
else if (prop.value[prop_name] is CharDictProperty dict_prop)
{
row = new PropertyRow(prop_name, row_path);
this.populate_property_rows(row.children, row_path, dict_prop);
}
if (row is not null)
{
prop_rows.Add(row);
}
}
}
internal override void AddCustomNodeProperties(VisualElement parentElement, AbstractMaterialNode nodeBase, Action setNodesAsDirtyCallback, Action updateNodeViewsCallback)
{
var node = nodeBase as ProceduralVirtualTextureNode;
var hlslDecls = Enum.GetValues(typeof(HLSLDeclaration));
var allowedDecls = new List <HLSLDeclaration>();
for (int i = 0; i < hlslDecls.Length; i++)
{
HLSLDeclaration decl = (HLSLDeclaration)hlslDecls.GetValue(i);
var allowed = node.AllowHLSLDeclaration(decl);
if (allowed)
{
allowedDecls.Add(decl);
}
}
var propertyRow = new PropertyRow(new Label("Shader Declaration"));
var popupField = new PopupField <HLSLDeclaration>(
allowedDecls,
node.shaderDeclaration,
(h => allHLSLDeclarationStrings[(int)h]),
(h => allHLSLDeclarationStrings[(int)h]));
popupField.RegisterValueChangedCallback(
evt =>
{
if (node.shaderDeclaration == evt.newValue)
{
return;
}
setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo("Change PVT shader declaration");
node.shaderDeclaration = (UnityEditor.ShaderGraph.Internal.HLSLDeclaration)evt.newValue;
updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
propertyRow.Add(popupField);
parentElement.Add(propertyRow);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
IEnumerable <string> fieldToDraw,
string labelName,
out VisualElement textArrayField,
int indentLevel = 0)
{
var propertyRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
textArrayField = new PopupField <string>(fieldToDraw.ToList(), 0);
propertyRow.Add(textArrayField);
var popupField = (PopupField <string>)textArrayField;
popupField.RegisterValueChangedCallback(evt =>
{
valueChangedCallback(popupField.index);
});
propertyRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(propertyRow);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
Vector4 fieldToDraw,
string labelName,
out VisualElement propertyVec4Field,
int indentLevel = 0)
{
var vector4Field = new Vector4Field {
value = fieldToDraw
};
var inputFields = vector4Field.Query("unity-text-input").ToList();
foreach (var inputField in inputFields)
{
inputField.RegisterCallback <KeyDownEvent>(m_KeyDownCallback);
inputField.RegisterCallback <FocusOutEvent>(m_FocusOutCallback);
}
vector4Field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (mUndoGroup == -1)
{
preValueChangeCallback?.Invoke();
}
valueChangedCallback(evt.newValue);
postValueChangeCallback?.Invoke();
});
propertyVec4Field = vector4Field;
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyVec4Field);
defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(defaultRow);
}
public RollPropertyView(Row row)
{
this.row = row;
propRow = row.Components.Get <PropertyRow>();
label = new ThemedSimpleText {
Text = propRow.Animator.TargetPropertyPath,
ForceUncutText = false,
VAlignment = VAlignment.Center,
OverflowMode = TextOverflowMode.Ellipsis,
LayoutCell = new LayoutCell(Alignment.LeftCenter, float.MaxValue)
};
propIcon = new Image {
LayoutCell = new LayoutCell(Alignment.Center),
Texture = IconPool.GetTexture("Nodes.Unknown"),
MinMaxSize = new Vector2(16, 16)
};
widget = new Widget {
Padding = new Thickness {
Left = 4, Right = 2
},
MinHeight = TimelineMetrics.DefaultRowHeight,
Layout = new HBoxLayout {
DefaultCell = new DefaultLayoutCell(Alignment.Center)
},
Nodes =
{
(spacer = new Widget()),
Spacer.HSpacer(6),
propIcon,
Spacer.HSpacer(3),
label,
CreateLockAnimationButton(),
Spacer.HSpacer(Theme.Metrics.DefaultToolbarButtonSize.X),
Spacer.HSpacer(Theme.Metrics.DefaultToolbarButtonSize.X)
},
};
widget.Components.Add(new AwakeBehavior());
widget.CompoundPresenter.Push(new SyncDelegatePresenter <Widget>(RenderBackground));
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
Color fieldToDraw,
string labelName,
out VisualElement propertyColorField,
int indentLevel = 0)
{
var colorField = new ColorField {
value = fieldToDraw, showEyeDropper = false, hdr = false
};
if (valueChangedCallback != null)
{
colorField.RegisterValueChangedCallback(evt => { valueChangedCallback((Color)evt.newValue); });
}
propertyColorField = colorField;
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyColorField);
return(defaultRow);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
Enum fieldToDraw,
string labelName,
Enum defaultValue,
out VisualElement propertyVisualElement,
int indentLevel = 0)
{
var row = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
propertyVisualElement = new EnumField(defaultValue);
row.Add((EnumField)propertyVisualElement, (field) =>
{
field.value = fieldToDraw;
});
if (valueChangedCallback != null)
{
var enumField = (EnumField)propertyVisualElement;
enumField.RegisterValueChangedCallback(evt => valueChangedCallback(evt.newValue));
}
return(row);
}
public virtual void VisitPropertyRow(PropertyRow row)
{
}
