public JToken Serialize(object value, Metadata.TypeInfo typeInfo) { if (value == null) { return(JValue.CreateNull()); } // Arrays if (typeInfo.IsArray) { return(SerializeArray(value, typeInfo)); } // Enums if (metadata.Enums.TryGetValue(typeInfo.Name, out Metadata.Enum enumMeta)) { return(SerializeEnum(value)); } // Primitive types if (Enum.TryParse(typeInfo.Name, out Metadata.PrimitiveType result)) { return(result == Metadata.PrimitiveType.Void ? JValue.CreateNull() : new JValue(value)); } // Entity if (metadata.Entities.TryGetValue(typeInfo.Name, out Metadata.Entity entity)) { return(SerializeEntity(value, entity, typeInfo)); } throw new SerializationException("Unknown type: " + typeInfo.Name); }
// public PropertyImpl(SpecifyParametersForm owner, string name, Metadata.TypeInfo type, IList <Attribute> attributes, string category, object value) : base(owner, name, false, type, type, new Metadata.Parameter[0], false) { this.attributes = attributes; this.category = category; this.value = value; }
/// <summary> /// Deserializes a <c>jsonValue</c> /// </summary> /// <param name="jsonValue"></param> /// <param name="typeInfo"></param> /// <returns></returns> public object Deserialize(JToken jsonValue, Metadata.TypeInfo typeInfo) { if (jsonValue is JValue val && val.Value == null) { return(null); } // Arrays if (typeInfo.IsArray) { return(DeserializeArray(jsonValue, typeInfo)); } // Enums if (metadata.Enums.TryGetValue(typeInfo.Name, out Metadata.Enum enumMeta)) { return(DeserializeEnum(jsonValue, enumMeta)); } // Primitive types if (Enum.TryParse(typeInfo.Name, out Metadata.PrimitiveType result)) { return(jsonValue.ToObject(typeInfo.Type)); } // Entity if (metadata.Entities.TryGetValue(typeInfo.Name, out Metadata.Entity entity)) { return(DeserializeObject(jsonValue as JObject, entity)); } throw new SerializationException("Unknown type: " + typeInfo.Name); }
// public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_Property creator, string category, bool referenceSupport) : base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly) { this.creator = creator; this.category = category; this.referenceSupport = referenceSupport; }
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Sphere sphere) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Sphere = sphere; }
// public EditorAction_NewResource(Metadata.TypeInfo type) { this.type = type; ImageSmall = Properties.Resources.New_16; ImageBig = Properties.Resources.New_32; QatSupport = true; GetState += delegate(EditorAction.GetStateContext context) { context.Enabled = true; }; Click += delegate(EditorAction.ClickContext context) { var initData = new NewObjectWindow.CreationDataClass(); var window = EditorAPI.FindWindow <ResourcesWindow>(); string directory = window.ContentBrowser1.GetDirectoryPathOfSelectedFileOrParentDirectoryItem(); if (!string.IsNullOrEmpty(directory)) { initData.initFileCreationDirectory = VirtualPathUtility.GetVirtualPathByReal(directory); } initData.initLockType = type; EditorAPI.OpenNewObjectWindow(initData); }; }
void TryNewObject(Metadata.TypeInfo lockType) { if (!CanNewObject(out List <Component> parentsForNewObjects)) { return; } var data = new NewObjectWindow.CreationDataClass(); data.initDocumentWindow = this; data.initParentObjects = new List <object>(); data.initParentObjects.AddRange(parentsForNewObjects); //!!!! //уникальное имя data.initLockType = lockType; data.initSupportAutoCreateAndClose = lockType != null; //!!!!бывает что создавать другой объект? например для меша создавать mesh in space. где еще так //!!!!выделить после создания EditorAPI.OpenNewObjectWindow(data); }
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Frustum frustum) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Frustum = frustum; }
void Update() { if (needUpdate) { //!!!!slowly? var demandedReturnType = GetDemandedReturnType(); if (demandedReturnType != createdPropertyReturnType || property == null) { Clear(); if (Enabled) //!!!!? { needUpdate = false; if (demandedReturnType != null) { //!!!!TypeInfo? Type unrefNetType = ReferenceUtility.GetUnreferencedType(demandedReturnType.GetNetType()); var type = MetadataManager.GetTypeOfNetType(unrefNetType); //!!!! var typeUnreferenced = type; var p = new PropertyImpl(this, "Output", false, type, typeUnreferenced, new Metadata.Parameter[0], true, "Parameter", false); p.Description = ""; property = p; createdPropertyReturnType = demandedReturnType; } } } } }
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Plane[] planes) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Planes = planes; }
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Ray ray) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Ray = ray; }
//////////// public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_ConvertTo creator, string category, string displayName) : base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly) { this.creator = creator; this.category = category; this.displayName = displayName; }
public GetObjectsItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Bounds bounds) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Bounds = bounds; }
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Box box) { this.CastType = castType; this.SelectedTypeOnly = selectedTypeOnly; this.VisibleOnly = visibleOnly; this.Box = box; }
public Tab(string name, string type, Metadata.TypeInfo visibleOnlyForType = null, VisibleConditionDelegate visibleCondition = null) { Name = name; Type = type; VisibleOnlyForType = visibleOnlyForType; VisibleCondition = visibleCondition; }
//!!!!везде метод применить там где "CreateComponent("? //!!!!расширять метод public static int GetNewObjectInsertIndex(Component parent, Metadata.TypeInfo objectType) { //Rendering effects if (MetadataManager.GetTypeOfNetType(typeof(Component_RenderingEffect)).IsAssignableFrom(objectType)) { if (GetRenderingEffectDefaultOrderOfEffect(objectType, out var value)) { int index = 0; foreach (var child in parent.Components) { if (MetadataManager.GetTypeOfNetType(typeof(Component_RenderingEffect)).IsAssignableFrom(child.BaseType)) { if (GetRenderingEffectDefaultOrderOfEffect(child.BaseType, out var childValue)) { if (value < childValue) { return(index); } } } index++; } } } return(-1); }
// public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, string category, string displayName, bool referenceSupport, Metadata.Parameter parameter, bool invoke) : base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly) { this.category = category; this.displayName = displayName; this.referenceSupport = referenceSupport; this.parameter = parameter; this.invoke = invoke; }
//////////// public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_MethodBody creator, string category, string displayName, ParameterType parameterType, int invokeParameterIndex) : base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly) { this.creator = creator; this.category = category; this.displayName = displayName; this.parameterType = parameterType; this.invokeParameterIndex = invokeParameterIndex; }
public static void Add(Metadata.TypeInfo type) { var typeName = type.Name; if (!string.IsNullOrEmpty(Favorites)) { Favorites += "|"; } Favorites += typeName; }
//!!!!new public static Metadata.TypeInfo GetUnreferencedType(Metadata.TypeInfo type) { var netType = type.GetNetType(); if (IsReferenceType(netType)) { return(MetadataManager.GetTypeOfNetType(GetUnderlyingType(netType))); } return(type); }
EventImpl CreateEvent() { Metadata.TypeInfo eventHandlerType = null; //EventHandlerType property var eventHandlerTypeProperty = EventHandlerType; if (eventHandlerTypeProperty.ReferenceSpecified) { eventHandlerType = eventHandlerTypeProperty; } else { //!!!! //var parameters = new List<Component_MemberParameter>(); //foreach( var p in GetComponents<Component_MemberParameter>( false, false ) ) //{ // if( p.Enabled ) // parameters.Add( p ); //} //var parameters2 = new List<Metadata.Parameter>(); //foreach( var p in parameters ) //{ // Metadata.Parameter p2 = p.CreateMetadataParameter(); // if( p2 == null ) // { // //!!!! // return null; // } // parameters2.Add( p2 ); //} ////!!!!? //var args = new List<Type>(); //foreach( var param in netMethod.GetParameters() ) // args.Add( param.ParameterType ); //args.Add( netMethod.ReturnType ); //var delDecltype = Expression.GetDelegateType( args.ToArray() ); } if (eventHandlerType != null) { var _event = new EventImpl(Parent, Name, Static, eventHandlerType, this); _event.Description = Description; return(_event); } else { return(null); } }
public static bool CheckTypeSupportedByPlayer(Metadata.TypeInfo type) { foreach (var t in supportedTypesByPlayer) { if (t.IsAssignableFrom(type)) { return(true); } } return(false); }
private JToken SerializeArray(object value, Metadata.TypeInfo typeInfo) { var array = value as IEnumerable; var tokens = new List <JToken>(); foreach (object arrValue in array) { JToken token = Serialize(arrValue, typeInfo.GetElementInfo()); tokens.Add(token); } return(new JArray(tokens.ToArray())); }
static bool GetRenderingEffectDefaultOrderOfEffect(Metadata.TypeInfo type, out double value) { var attribs = type.GetCustomAttributes(typeof(Component_RenderingEffect.DefaultOrderOfEffectAttribute), true); if (attribs.Length != 0) { value = ((Component_RenderingEffect.DefaultOrderOfEffectAttribute)attribs[0]).Value; return(true); } value = -1; return(false); }
public static bool Contains(Metadata.TypeInfo type) { var typeNames = Favorites.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); foreach (var typeName2 in typeNames) { if (typeName2 == type.Name) { return(true); } } return(false); }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public static Component CreateComponent(Metadata.TypeInfo type, object[] constructorParams, bool createHierarchyController, bool componentEnable) { var component = (Component)type.InvokeInstance(constructorParams); component.Enabled = componentEnable; if (createHierarchyController) { CreateHierarchyControllerForRootComponent(component, null, true); //, true ); } return(component); }
string GetExtension(Metadata.TypeInfo type) { //!!!!а как для своих типов расширения добавлять. нужно атрибуты уметь типу добавлять. тогда еще и свои типы атрибутов может быть var ar = type.GetNetType().GetCustomAttributes(typeof(ResourceFileExtensionAttribute), true); if (ar.Length != 0) { var attr = (ResourceFileExtensionAttribute)ar[0]; return(attr.Extension); } //!!!!! return("UNKNOWN"); }
private object DeserializeArray(JToken jsonValue, Metadata.TypeInfo typeInfo) { var jsonArr = jsonValue as JArray; if (jsonArr == null) { throw new SerializationException("Array type expected"); } var array = Array.CreateInstance(typeInfo.Type, jsonArr.Count); for (int n = 0; n < jsonArr.Count; n++) { array.SetValue(Deserialize(jsonArr[n], typeInfo.GetElementInfo()), n); } return(array); }
void UpdateSelectedType() { Metadata.TypeInfo newType = null; bool newTypeCanSelect = false; ContentBrowser.Item item = null; if (contentBrowser1.SelectedItems.Length != 0) { item = contentBrowser1.SelectedItems[0]; } if (item != null) { item.CalculateReferenceValue(null, MetadataManager.GetTypeOfNetType(typeof(Metadata.TypeInfo)), out string referenceValue, out bool canSet); if (canSet) { if (!string.IsNullOrEmpty(referenceValue)) { newType = (Metadata.TypeInfo)MetadataManager.GetValueByReference( contentBrowser1.SetReferenceModeData.demandedType.GetNetType(), null, referenceValue); newTypeCanSelect = true; } else { newTypeCanSelect = true; } } //check can be selected if (newType != null && !creationData.initDemandedType.IsAssignableFrom(newType)) { newType = null; newTypeCanSelect = false; } } //change if (selectedType != newType || selectedTypeCanSelect != newTypeCanSelect) { selectedType = newType; selectedTypeCanSelect = newTypeCanSelect; SelectedTypeChanged(); } }
public static void Remove(Metadata.TypeInfo type) { var typeNames = Favorites.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); Favorites = ""; foreach (var typeName2 in typeNames) { if (typeName2 != type.Name) { if (!string.IsNullOrEmpty(Favorites)) { Favorites += "|"; } Favorites += typeName2; } } }