public ProcessResult Process(ElementNode node)
{
var processResult = new ProcessResult();
if (string.IsNullOrEmpty(node?.Value?.ToString()))
{
return(processResult);
}
var input = node.Value.ToString();
// Hash the id part for "Reference.reference" node and hash whole input for other node types
if (node.IsReferenceStringNode())
{
var newReference = ReferenceUtility.TransformReferenceId(input, _cryptoHashFunction);
node.Value = newReference;
}
else
{
node.Value = _cryptoHashFunction(input);
}
_logger.LogDebug($"Fhir value '{input}' at '{node.Location}' is hashed to '{node.Value}'.");
processResult.AddProcessRecord(AnonymizationOperations.CryptoHash, node);
return(processResult);
}
public override void UpdateControl()
{
base.UpdateControl();
var control = (IHCColorValuePowered)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBarPower;
if (powerRange != null)
{
var netType = Property.Type.GetNetType();
bool isReferenceType = ReferenceUtility.IsReferenceType(netType);
var values = GetValues();
if (values != null)
{
trackBar.Enabled = CanEditValue();
//bool referenceSpecified = false;
//if( isReferenceType && value != null )
// referenceSpecified = ( (IReference)value ).ReferenceSpecified;
//if( trackBar.Enabled != !referenceSpecified )
// trackBar.Enabled = !referenceSpecified;
//!!!!new
if (!trackBarModifying) //if( !trackBar.Focused )
{
UpdateTrackBar();
}
}
}
}
private bool IsIntegerType()
{
var type = ReferenceUtility.GetUnreferencedType(itemProperty.Property.Type).GetNetType();
//var type = itemProperty.Property.Type.GetNetUnreferencedType();
return(type == typeof(RangeI) || type == typeof(Vector2I));
}
object ParseValueFromTextBox(out bool invalid)
{
var control = (IHCTextBox)CreatedControlInsidePropertyItemControl;
var netType = Property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(netType);
try
{
invalid = false;
var text = control.TextBox.Text;
if (typeof(ICanParseFromAndConvertToString).IsAssignableFrom(unrefType))
{
var parseMethod = unrefType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static);
if (parseMethod != null)
{
return(parseMethod.Invoke(null, new object[] { text }));
}
}
return(SimpleTypes.ParseValue(unrefType, text));
}
catch
{
invalid = true;
return(null);
}
}
public RangeDropDownControl(HCItemProperty itemProperty)
{
InitializeComponent();
AddOkCancelButtons(out _, out _);
this.itemProperty = itemProperty;
rangeAttr = (RangeAttribute)itemProperty.Property.GetCustomAttributes(typeof(RangeAttribute)).FirstOrDefault();
if (rangeAttr == null)
{
rangeAttr = new RangeAttribute(0, 100); // default
}
SetupUIApplicableRange();
minTrackBar.ValueChanged += new EventHandler(anyTrackBar_ValueChanged);
maxTrackBar.ValueChanged += new EventHandler(anyTrackBar_ValueChanged);
object obj = ReferenceUtility.GetUnreferencedValue(itemProperty.GetValues()[0]);
value = RangeConverter.ObjectToRange(obj);
propertyItemForUndoSupport = itemProperty.GetItemInHierarchyToRestoreValues();
propertyItemForUndoSupport.SaveValuesToRestore();
UpdateTrackBarsAndTextBoxes();
EditorThemeUtility.ApplyDarkThemeToForm(this);
}
public void RedrawImages()
{
var dimg = (UIImage)this.GetComponentByPath("DragImage");
for (int j = 0; j < 4; j++)
{
for (int i = 0; i < 5; i++)
{
var n = (i + j * 5).ToString();
var imgn2 = (UIImage)this.GetComponentByPath("Window 2\\" + n);
imgn2.SourceImage = dimg.SourceImage;
}
}
for (int i = 0; i < 5; i++)
{
var n1 = (i).ToString();
var imgn1 = (UIImage)this.GetComponentByPath("Window 1\\" + n1);
var impath1 = InvUtils.getImagePath(SimulationApp.PlayerInv, i);
if (impath1 != null && impath1 != "")
{
imgn1.SourceImage = ReferenceUtility.MakeReference <Component_Image>(impath1);
}
else
{
imgn1.SourceImage = dimg.SourceImage;
}
}
}
/// <summary>
/// Getting from only created items. Not all _Member items can be created (expanded).
/// </summary>
/// <param name="reference"></param>
/// <returns></returns>
ContentBrowser.Item GetItemByReference(string reference)
{
//!!!!slowly
//!!!!multiselection?
//_Null
if (string.IsNullOrEmpty(reference))
{
foreach (var item in contentBrowser1.Items)
{
if (item is ContentBrowserItem_Null)
{
return(item);
}
}
return(null);
}
foreach (var item in contentBrowser1.Items)
{
item.CalculateReferenceValue(setReferenceModeData.selectedComponents[0], setReferenceModeData.property.TypeUnreferenced,
out string itemReferenceValue, out bool itemCanSet);
if (ReferenceUtility.EqualsReferences(itemReferenceValue, reference))
{
return(item);
}
}
return(null);
}
public override void UpdateControl()
{
base.UpdateControl();
var control = (IHCTextBoxNumeric)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBar;
if (range != null)
{
var netType = Property.Type.GetNetType();
bool isReferenceType = ReferenceUtility.IsReferenceType(netType);
var values = GetValues();
if (values != null)
{
trackBar.Enabled = CanEditValue();
//!!!!new
if (!trackBarModifying) //if( !trackBar.Focused )
{
UpdateTrackBar();
}
}
}
}
//!!!!если надо, то как EditorAction
//public static void ShowObjectDetailsAsDocument( object obj )
//{
// List<string> lines = new List<string>( 256 );
// lines.Add( obj.ToString() );
// lines.Add( "" );
// lines.Add( "----------------------------------------------------------------------------------------------------" );
// lines.Add( "Inheritance Hierarchy" );
// lines.Add( "" );
// var type = MetadataManager.MetadataGetType( obj );
// int step = 0;
// do
// {
// lines.Add( new string( ' ', step * 3 ) + type.ToString() );
// step++;
// type = type.BaseType;
// } while( type != null );
// //lines.Add( "Type \'" + MetadataManager.MetadataGetType( obj ).ToString() + "\'" );
// //lines.Add( ".NET type \'" + obj.GetType().ToString() + "\'" );
// lines.Add( "" );
// lines.Add( "----------------------------------------------------------------------------------------------------" );
// lines.Add( "" );
// foreach( var member in MetadataManager.MetadataGetMembers( obj ) )
// {
// Metadata.Method method = member as Metadata.Method;
// if( method != null )
// {
// lines.Add( method.Signature );
// lines.Add( " " + method.ToString() );
// lines.Add( "" );
// }
// }
// lines.Add( "----------------------------------------------------------------------------------------------------" );
// lines.Add( "" );
// foreach( var member in MetadataManager.MetadataGetMembers( obj ) )
// {
// Metadata.Event evt = member as Metadata.Event;
// if( evt != null )
// {
// lines.Add( evt.Signature );
// lines.Add( " " + evt.ToString() );
// lines.Add( "" );
// }
// }
// lines.Add( "----------------------------------------------------------------------------------------------------" );
// lines.Add( "" );
// foreach( var member in MetadataManager.MetadataGetMembers( obj ) )
// {
// Metadata.Property prop = member as Metadata.Property;
// if( prop != null )
// {
// lines.Add( prop.Signature );
// lines.Add( " " + prop.ToString() );
// lines.Add( "" );
// }
// }
// //lines.Add( "Type: " + MetadataManager.MetadataGetType( obj ).ToString() );
// //lines.Add( "Net type: " + obj.GetType().ToString() );
// //lines.Add( "" );
// //lines.Add( "ToString(): " + obj.ToString() );
// //lines.Add( "" );
// //lines.Add( "----------------------------------------------------------------------------------------------------" );
// //lines.Add( "Metadata:" );
// //!!!!!!
// //if( component != null )
// //{
// // List<string> list = new List<string>();
// // var members = component.MetadataGetMembers( true );
// // list.Add( component.ToString() );
// // list.Add( "" );
// // list.Add( "Events:" );
// // foreach( var m in members )
// // {
// // var evn = m as Metadata.Event;
// // if( evn != null )
// // list.Add( evn.ToString() + " - " + evn.Signature );
// // }
// // list.Add( "" );
// // list.Add( "Properties:" );
// // foreach( var m in members )
// // {
// // var p = m as Metadata.Property;
// // if( p != null )
// // list.Add( p.ToString() + " - " + p.Signature );
// // }
// // list.Add( "" );
// // list.Add( "Methods:" );
// // foreach( var m in members )
// // {
// // var method = m as Metadata.Method;
// // if( method != null )
// // list.Add( method.ToString() + " - " + method.Signature );
// // }
// // //!!!!!!log out
// // {
// // Log.Info( "" );
// // Log.Info( "" );
// // Log.Info( "---------------------------------- START -------------------------------------" );
// // foreach( var t in list )
// // Log.Info( t );
// // Log.Info( "----------------------------------- END --------------------------------------" );
// // }
// // viewport.GuiRenderer.AddTextLines( list, new Vec2( .03, .1 ), EHorizontalAlign.Left, EVerticalAlign.Top, 0,
// // new ColorValue( 1, 1, 0 ) );
// //}
// StringBuilder text = new StringBuilder();
// foreach( var line in lines )
// text.Append( line + "\r\n" );
// EditorForm.Instance.OpenTextAsDocument( text.ToString(), MetadataManager.MetadataGetType( obj ).ToString(), true );
//}
public static void SetPropertyReference(DocumentInstance document, object /* Component*/[] objects, Metadata.Property property, object[] indexers, string[] referenceValues)
{
var netType = property.Type.GetNetType();
var underlyingType = ReferenceUtility.GetUnderlyingType(netType);
var undoItems = new List <UndoActionPropertiesChange.Item>();
//!!!!try, catch? где еще
for (int n = 0; n < objects.Length; n++)
{
var obj = objects[n];
var value = ReferenceUtility.MakeReference(underlyingType, null, referenceValues[n]);
var oldValue = (IReference)property.GetValue(obj, indexers);
//bool change = true;
//if( /*skipSame && */oldValue != null && value.GetByReference == oldValue.GetByReference )
// change = false;
if (!value.Equals(oldValue))
{
property.SetValue(obj, value, indexers);
undoItems.Add(new UndoActionPropertiesChange.Item(obj, property, oldValue, indexers));
}
}
//undo
if (undoItems.Count != 0)
{
var action = new UndoActionPropertiesChange(undoItems.ToArray());
document.UndoSystem.CommitAction(action);
document.Modified = true;
}
}
public override void UpdateControl()
{
base.UpdateControl();
var control = (IHCItemСontentBrowser)CreatedControlInsidePropertyItemControl;
control.Browser.ReadOnlyHierarchy = !CanEditValue();
var values = GetValues();
if (values == null)
{
return;
}
//!!!!multiselection
var value = values[0];
object unrefValue = ReferenceUtility.GetUnreferencedValue(value);
if (!object.Equals(currentValue, unrefValue))
{
OnValueChanged(currentValue, unrefValue);
currentValue = unrefValue;
}
}
public EnumDropDownControl(HCItemEnumDropDown itemProperty)
{
InitializeComponent();
this.itemProperty = itemProperty;
propertyType = ReferenceUtility.GetUnreferencedType(itemProperty.Property.Type.GetNetType());
if (propertyType.IsEnum)
{
enumDataType = Enum.GetUnderlyingType(propertyType);
isFlag = propertyType.IsDefined(typeof(FlagsAttribute), false);
}
currentValue = ReferenceUtility.GetUnreferencedValue(itemProperty.GetValues()[0]);
propertyItemForUndoSupport = itemProperty.GetItemInHierarchyToRestoreValues();
propertyItemForUndoSupport.SaveValuesToRestore();
listViewEnum.Items.Clear();
listViewEnum.CheckBoxes = isFlag;
foreach (var val in Enum.GetValues(propertyType))
{
var info = new EnumInfo(val);
var displayName = info.DisplayName;
var description = info.Description;
itemProperty.Owner.PerformOverridePropertyEnumItem(itemProperty, ref displayName, ref description);
listViewEnum.Items.Add(new ListViewItem
{
Text = displayName,
ToolTipText = description,
Tag = info
});
//listViewEnum.Items.Add( new ListViewItem
//{
// Text = info.DisplayName,
// ToolTipText = info.Description,
// Tag = info
//} );
}
UpdateCheckState();
int itemCount = listViewEnum.Items.Count;
var height = itemCount * (Font.Height + DpiHelper.Default.ScaleValue(4)) + 3;
var width = ((IHCProperty)itemProperty.CreatedControl).EditorControl.Width; //TODO: bad incapsulation. why this control should know about EditorControl.Width ?
Size = new Size(width, Math.Min(dropdownHeight, height));
if (EditorAPI.DarkTheme)
{
listViewEnum.BackColor = Color.FromArgb(54, 54, 54);
listViewEnum.ForeColor = Color.FromArgb(240, 240, 240);
}
}
private void TrackBar_ValueChanged(object sender, EventArgs e)
{
if (trackBarDisableValueChangedEvent)
{
return;
}
//!!!!new
if (!trackBarFocused)
{
return;
}
//begin modifying. save old values for undo
if (!trackBarModifying)
{
trackBarItemInHierarchyToAddUndo = GetItemInHierarchyToRestoreValues();
trackBarItemInHierarchyToAddUndo.SaveValuesToRestore();
trackBarModifying = true;
}
var control = (IHCColorValuePowered)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBarPower;
trackBarDisableValueChangedEvent = true;
var netType = Property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(netType);
var values = GetValues();
if (values == null)
{
return;
}
//!!!!multiselection
var value = values[0];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
var color = (ColorValuePowered)unrefValue;
try
{
var power = powerRange.GetValueFromTrackBar(false, trackBar.Value);
color.Power = (float)power;
SetValue(color, false);
}
catch
{
}
trackBarDisableValueChangedEvent = false;
}
private void UpdateItemProperty()
{
if (itemProperty != null && itemProperty.CanEditValue())
{
var type = ReferenceUtility.GetUnreferencedType(itemProperty.Property.Type).GetNetType();
//var type = itemProperty.Property.Type.GetNetUnreferencedType();
itemProperty.SetValue(RangeConverter.ConvertRange(value, type), false);
}
valueWasChanged = true;
}
public override void UpdateControl()
{
base.UpdateControl();
var control = (IHCLabel)CreatedControlInsidePropertyItemControl;
var values = GetValues();
if (values == null)
{
return;
}
var valueResult = "";
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
var stringValue = GetValueText(unrefValue);
if (nValue == 0)
{
valueResult = stringValue;
}
else
{
if (valueResult != stringValue)
{
valueResult = "";
}
}
}
if (control.Label2 != null)
{
control.Label2.Text = valueResult;
}
if (Property != null)
{
if (control.Label2.Enabled != !Property.ReadOnly)
{
control.Label2.Enabled = !Property.ReadOnly;
}
}
////var netType = Property.Type.GetNetType();
////var unrefType = ReferenceUtils.GetUnreferencedType( netType );
////var type = MetadataManager.GetTypeOfNetType( unrefType );
////if( control.Label1 != null )
//// control.Label1.Text = Property.Name;
}
private void TrackBar_ValueChanged(object sender, EventArgs e)
{
if (trackBarDisableValueChangedEvent)
{
return;
}
if (!trackBarFocused)
{
return;
}
//begin modifying. save old values for undo
if (!trackBarModifying)
{
trackBarItemInHierarchyToAddUndo = GetItemInHierarchyToRestoreValues();
trackBarItemInHierarchyToAddUndo.SaveValuesToRestore();
trackBarModifying = true;
}
var control = (IHCTextBoxNumeric)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBar;
trackBarDisableValueChangedEvent = true;
var netType = Property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(netType);
try
{
double doubleValue = range.GetValueFromTrackBar(IsInteger(), trackBar.Value);
//conversion by means string
string str;
if (IsInteger())
{
str = Convert.ToInt64(doubleValue).ToString();
}
else
{
str = doubleValue.ToString();
}
var value = SimpleTypes.ParseValue(unrefType, str);
SetValue(value, false);
}
catch
{
}
trackBarDisableValueChangedEvent = false;
}
protected override void OnEnabledInSimulation()
{
//create a mesh
mesh = CreateComponent <Component_Mesh>(enabled: false);
mesh.Name = "Mesh 1";
//generate vertices. use StandardVertex to make it easier
StandardVertex.StaticOneTexCoord[] vertices = new StandardVertex.StaticOneTexCoord[4];
var v = new StandardVertex.StaticOneTexCoord();
v.Position = new Vector3F(-0.4f, -0.4f, 0f);
v.Normal = new Vector3F(0, 0, 1);
v.Tangent = new Vector4F(1, 0, 0, 0);
v.Color = new ColorValue(1, 1, 1);
//v.TexCoord0 = new Vector2F(-1, -1);
vertices[0] = v;
v.Position = new Vector3F(0.4f, -0.4f, 0);
vertices[1] = v;
v.Position = new Vector3F(0.4f, 0.4f, 0);
vertices[2] = v;
v.Position = new Vector3F(-0.4f, 0.4f, 0);
vertices[3] = v;
//generate indices
var indices = new int[] { 0, 1, 2, 2, 3, 0 };
//create geometry of the mesh
geometry = mesh.CreateComponent <Component_MeshGeometry>();
geometry.VertexStructure = StandardVertex.MakeStructure(StandardVertex.Components.StaticOneTexCoord, true, out int vertexSize);
geometry.Vertices = ConvertVertices(vertices);
geometry.Indices = indices;
//mesh has been created, now we can enable it
mesh.Enabled = true;
meshInSpace = CreateComponent <Component_MeshInSpace>(enabled: false);
meshInSpace.Transform = new Transform(new Vector3(1, 1, 1));
//make reference to the mesh. 'Root' reference - global path from scene root.
meshInSpace.Mesh = ReferenceUtility.MakeRootReference(mesh);
meshInSpace.Color = new ColorValue(1, 0, 0);
meshInSpace.Enabled = true;
}
public override void Check(
CutsceneEditor editor,
ErrorManager manager,
int tokenIndex,
Token token,
object value,
int fieldIndex,
FieldInfo info)
{
if (!(value is Reference) && !(value is FutureReference))
{
return;
}
Increment(ReferenceUtility.GetID(value));
}
bool IsInteger()
{
var netType = Property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(netType);
return
(unrefType == typeof(sbyte) ||
unrefType == typeof(byte) ||
unrefType == typeof(char) ||
unrefType == typeof(short) ||
unrefType == typeof(ushort) ||
unrefType == typeof(int) ||
unrefType == typeof(uint) ||
unrefType == typeof(long) ||
unrefType == typeof(ulong));
}
public virtual Type GetSuitableItemType(Metadata.Member member)
{
Type itemType = null;
//override item type
GetSuitableItemTypeOverride?.Invoke(this, member, ref itemType);
if (itemType == null)
{
var editorAttr = (EditorAttribute)member.GetCustomAttributes(typeof(EditorAttribute), true).FirstOrDefault();
if (editorAttr != null)
{
var editorType = EditorUtility.GetTypeByName(editorAttr.EditorTypeName);
if (typeof(HCItemProperty).IsAssignableFrom(editorType))
{
return(editorType);
}
}
var property = member as Metadata.Property;
if (property != null)
{
//var attribs = property.GetCustomAttributes( typeof( SelectBaseAttribute ), true );
//if( attribs.Length != 0 )
//{
// //get item type by SelectBaseAttribute
// var attrib = (SelectBaseAttribute)attribs[ 0 ];
// itemType = attrib.GetHierarchicalContainerItemType();
//}
//else
//{
//get item type by property type
var originalType = property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(originalType);
itemType = GetSuitableItemTypeByPropertyType(unrefType);
//}
}
var _event = member as Metadata.Event;
if (_event != null)
{
return(EditorAssemblyInterface.Instance.GetTypeByName("NeoAxis.Editor.HCItemEvent")); // typeof( HCItemEvent );
}
}
return(itemType);
}
public override void UpdateControl()
{
base.UpdateControl();
var control = (IHCCollection)CreatedControlInsidePropertyItemControl;
var values = GetValues();
if (values == null)
{
return;
}
var valueResult = "";
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
string value2;
if (unrefValue != null)
{
value2 = GetValueText(unrefValue);
}
else
{
value2 = "(Null)";
}
if (nValue == 0)
{
valueResult = value2;
}
else
{
if (valueResult != value2)
{
valueResult = "";
}
}
}
if (control.Label2 != null)
{
control.Label2.Text = valueResult;
}
}
public void Button_Click(NeoAxis.Component_ButtonInSpace sender)
{
var scene = sender.ParentScene;
var ground = scene.GetComponent("Ground") as Component_MeshInSpace;
if (ground != null)
{
if (!ground.ReplaceMaterial.ReferenceSpecified)
{
ground.ReplaceMaterial = ReferenceUtility.MakeReference(@"Samples\Starter Content\Materials\Concrete 3x3 meters\Concrete 3x3 meters.material");
}
else
{
ground.ReplaceMaterial = null;
}
}
}
void UpdatePreviewColor()
{
var values = GetValues();
if (values == null)
{
return;
}
var valueResult = ColorValue.Zero;
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
ColorValue color;
if (unrefValue is ColorValuePowered)
{
color = ((ColorValuePowered)unrefValue).Color;
}
else
{
color = (ColorValue)unrefValue;
}
if (nValue == 0)
{
valueResult = color;
}
else
{
if (valueResult != color)
{
valueResult = ColorValue.One;
}
}
}
var control = (IHCColorValue)CreatedControlInsidePropertyItemControl;
if (control != null)
{
control.PreviewButton.PreviewColor = valueResult;
}
}
static void CreateMesh(ImportContext context, List <LOD> lods, string name, Component parent)
{
var settings = context.settings;
var mesh = parent.CreateComponent <Component_Mesh>(enabled: false);
mesh.Name = name;
{
var lodData = lods[0];
foreach (var geometry in lodData.geometries)
{
ImportGeometry(context, mesh, geometry);
}
MeshGetIsBillboard(context, mesh);
if (settings.component.MergeMeshGeometries)
{
mesh.MergeGeometriesWithEqualVertexStructureAndMaterial();
}
}
for (int nLod = 1; nLod < lods.Count; nLod++)
{
var lod = mesh.CreateComponent <Component_MeshLevelOfDetail>();
lod.Name = $"LOD {nLod}";
lod.Distance = settings.component.LODDistance * nLod;
var lodMesh = lod.CreateComponent <Component_Mesh>();
lodMesh.Name = "Mesh";
var lodData = lods[nLod];
foreach (var geometry in lodData.geometries)
{
ImportGeometry(context, lodMesh, geometry);
}
MeshGetIsBillboard(context, lodMesh);
if (settings.component.MergeMeshGeometries)
{
lodMesh.MergeGeometriesWithEqualVertexStructureAndMaterial();
}
lod.Mesh = ReferenceUtility.MakeThisReference(lod, lodMesh);
}
mesh.Enabled = true;
}
public override void UpdateControl()
{
base.UpdateControl();
bool readOnly = !CanEditValue();
var control = ( HCGridDropDownButton /*IHCDropDownButton*/)CreatedControlInsidePropertyItemControl;
control.Button.Enabled = !readOnly;
//update width. Anchor for this control works bad in .NET Core
control.Button.Width = control.Width - control.Button.Location.X;
var values = GetValues();
if (values == null)
{
return;
}
object resultValue = null;
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
object unrefValue = ReferenceUtility.GetUnreferencedValue(value);
if (nValue == 0)
{
resultValue = unrefValue;
}
else
{
if (!Equals(resultValue, unrefValue))
{
resultValue = "";
}
}
}
if (!Equals(currentValue, resultValue))
{
OnValueChanged(currentValue, resultValue);
currentValue = resultValue;
}
}
Component_FlowGraphNode AddFlowGraphNode(Component_FlowGraph graph, Component subscribeTo)
{
var node = graph.CreateComponent <Component_FlowGraphNode>(enabled: false);
node.Name = node.BaseType.GetUserFriendlyNameForInstance();
node.Position = graph.EditorScrollPosition.ToVector2I();
var handler = node.CreateComponent <Component_EventHandler>();
handler.Name = handler.BaseType.GetUserFriendlyNameForInstance() + " " + _event.Name;
handler.Event = ReferenceUtility.MakeReference <ReferenceValueType_Event>(
null, ReferenceUtility.CalculateThisReference(handler, subscribeTo, _event.Signature));
node.ControlledObject = ReferenceUtility.MakeReference <Component>(null, ReferenceUtility.CalculateThisReference(node, handler));
node.Enabled = true;
return(node);
}
static void ImportGeometry(ImportContext context, Component parent, MeshData geom)
{
var geometry = parent.CreateComponent <Component_MeshGeometry>();
geometry.Name = GetFixedName(geom.Name);
CalcIndices.CalculateIndicesBySpatialSort(geom, out StandardVertex[] vertices, out int[] indices);
//CalcIndices.CalculateIndicesByOctree( m, out StandardVertexF[] verticesO, out int[] indicesO );
geometry.SetVertexDataWithRemovingHoles(vertices, geom.VertexComponents);
geometry.Indices = indices;
//set first material
context.materialByIndex.TryGetValue(0, out var material);
if (material != null)
{
geometry.Material = ReferenceUtility.MakeRootReference(material);
}
}
protected virtual void TextBoxTextChanged()
{
var values = GetValues();
if (values == null)
{
return;
}
var value = values[0];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
var v = ParseValueFromTextBox(out invalidValue);
if (!invalidValue)
{
try
{
if (!Equals(v, unrefValue) || values.Length > 1)
{
SetValue(v, true);
}
}
catch { }
}
//var control = (IHCTextBox)CreatedControlInsidePropertyItemControl;
//var netType = Property.Type.GetNetType();
//var unrefType = ReferenceUtils.GetUnreferencedType( netType );
//object v = null;
//try
//{
// v = SimpleTypesUtils.ParseValue( unrefType, control.TextBox1.Text );
// invalidValue = false;
// SetValue( v, true );
//}
//catch
//{
// invalidValue = true;
//}
}
void UpdateTrackBar()
{
var control = (IHCTextBoxNumeric)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBar;
var values = GetValues();
if (values == null)
{
return;
}
int resultValue = 0;
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
//conversion by means string
double doubleValue = double.Parse(unrefValue.ToString());
var value2 = range.GetTrackBarValue(IsInteger(), doubleValue);
if (nValue == 0)
{
resultValue = value2;
}
else
{
if (resultValue != value2)
{
resultValue = control.TrackBar.Minimum;
}
}
}
if (trackBar.Value != resultValue)
{
trackBarDisableValueChangedEvent = true;
trackBar.Value = resultValue;
trackBarDisableValueChangedEvent = false;
}
}
public override void UpdateControl()
{
base.UpdateControl();
bool readOnly = !CanEditValue();
var control = (IHCDropDownButton)CreatedControlInsidePropertyItemControl;
control.Button.Enabled = !readOnly;
var values = GetValues();
if (values == null)
{
return;
}
object resultValue = null;
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
object unrefValue = ReferenceUtility.GetUnreferencedValue(value);
if (nValue == 0)
{
resultValue = unrefValue;
}
else
{
if (!Equals(resultValue, unrefValue))
{
resultValue = "";
}
}
}
if (!Equals(currentValue, resultValue))
{
OnValueChanged(currentValue, resultValue);
currentValue = resultValue;
}
}
void UpdateTrackBar()
{
var control = (IHCColorValuePowered)CreatedControlInsidePropertyItemControl;
var trackBar = control.TrackBarPower;
var values = GetValues();
if (values == null)
{
return;
}
int resultValue = 0;
for (int nValue = 0; nValue < values.Length; nValue++)
{
var value = values[nValue];
var unrefValue = ReferenceUtility.GetUnreferencedValue(value);
var power = ((ColorValuePowered)unrefValue).Power;
var value2 = powerRange.GetTrackBarValue(false, power);
if (nValue == 0)
{
resultValue = value2;
}
else
{
if (resultValue != value2)
{
resultValue = control.TrackBarPower.Minimum;
}
}
}
if (trackBar.Value != resultValue)
{
trackBarDisableValueChangedEvent = true;
trackBar.Value = resultValue;
trackBarDisableValueChangedEvent = false;
}
}
