public static void SetVariableNames(Scene scene, VariantMapList list)
{
List <string> names = new List <string>(GetVariableNames(scene));
foreach (VariantMapRecord rec in list)
{
if (names.Contains(rec.Key))
{
continue;
}
else
{
names.Add(rec.Key);
}
}
scene.SetAttribute("Variable Names", new Variant(String.Join(";", names.ToArray())));
}
public static void Fill(VariantMap map, VariantMapList values)
{
string[] varNames = Enum.GetNames(typeof(VariantType));
foreach (VariantMapRecord rec in values)
{
Variant var = new Variant();
string keyname = rec.Key;
string name = varNames[(int)rec.Type];
string value = rec.Value;
var.FromString(varNames[(int)rec.Type], rec.Value);
if (rec.Key != null)
{
map.Set(rec.Key, var);
}
else
{
map.Set(rec.ExplicitKey, var);
}
}
}
public static VariantMapList Get(object src, PropertyDescriptor desc, VariantMap map)
{
Scene scene = src as Scene;
if (scene == null)
{
Node nd = src as Node;
if (nd == null)
{
UrhoBackend.Component cp = src as UrhoBackend.Component;
scene = cp.GetScene();
}
else
{
scene = nd.GetScene();
}
}
VariantMapList keys = new VariantMapList(desc, src);
List <string> varNames = new List <string>(Enum.GetNames(typeof(VariantType)));
List <StringHash> hashes = map.Keys();
foreach (StringHash sh in hashes)
{
Variant v = map.Get(sh);
string value = v.ToString();
VariantType vt = (VariantType)varNames.IndexOf(v.GetVarType());
VariantMapRecord rec = new VariantMapRecord(keys)
{
ExplicitKey = sh, Type = (VariantType)v.GetVarTypeID(), Value = v.ToString()
};
if (scene != null)
{
rec.Key = VariableUtils.GetVariableName(scene, rec.ExplicitKey);
}
rec.Enabled = true;
keys.Add(rec);
}
return(keys);
}
public static void SetVariableNames(Serializable serial, VariantMapList list)
{
Scene scene = serial as Scene;
if (scene != null)
{
SetVariableNames(scene, list);
return;
}
Node nd = serial as Node;
if (nd != null)
{
SetVariableNames(nd.GetScene(), list);
return;
}
UrhoBackend.Component comp = serial as UrhoBackend.Component;
if (comp != null)
{
SetVariableNames(comp.GetScene(), list);
return;
}
}
public VariantMapRecord(VariantMapList owner)
{
Owner = owner;
}
public override object GetEditor(Type editorBaseType)
{
if (attrInfo_.EnumNames != null && attrInfo_.EnumNames.Count > 0)
{
List <int> enumValues = new List <int>();
for (int i = 0; i < attrInfo_.EnumNames.Count; ++i)
{
enumValues.Add(i);
}
return(new EditorCore.Controls.PropertyGrid.NamedEnumEditor(attrInfo_.EnumNames.ToArray()));
}
if (attrInfo_.Name.EndsWith("Mask"))
{
return(new EditorCore.Controls.PropertyGrid.MaskEditor());
}
if (type_ == typeof(bool))
{
return(new Sce.Atf.Controls.PropertyEditing.BoolEditor());
}
else if (type_ == typeof(int))
{
return(new Sce.Atf.Controls.PropertyEditing.NumericEditor(typeof(int)));
}
else if (type_ == typeof(float))
{
return(new Sce.Atf.Controls.PropertyEditing.NumericEditor(typeof(float)));
}
else if (type_ == typeof(UrhoBackend.Vector3))
{
return(new EditorCore.Controls.PropertyGrid.VectorEditor(typeof(UrhoBackend.Vector3), new[] { "X", "Y", "Z" }));
}
else if (type_ == typeof(UrhoBackend.Vector2))
{
return(new EditorCore.Controls.PropertyGrid.VectorEditor(typeof(UrhoBackend.Vector2), new[] { "X", "Y", "Z" }));
}
else if (type_ == typeof(UrhoBackend.Vector4))
{
return(new EditorCore.Controls.PropertyGrid.VectorEditor(typeof(UrhoBackend.Vector4), new[] { "X", "Y", "Z", "W" }));
}
else if (type_ == typeof(UrhoBackend.Color))
{
return new Sce.Atf.Controls.PropertyEditing.ColorPickerEditor {
EnableAlpha = true
}
}
;
else if (type_ == typeof(UrhoBackend.ResourceRef))
{
return(new Sce.Atf.Controls.PropertyEditing.FileUriEditor(EditorCore.Interop.UrhoConstants.GetFilters(source_.GetAttributeDefault(attrName_).GetResourceRef())));
}
else if (type_ == typeof(UrhoBackend.VariantVector))
{
}
else if (type_ == typeof(UrhoBackend.ResourceRefList))
{
return(new EditorCore.Controls.PropertyGrid.ResourceRefListEditor());
}
else if (type_ == typeof(UrhoBackend.VariantMap))
{
Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor editor = new Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor();
editor.GetItemInsertersFunc = (context) =>
{
Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor.ItemInserter inserter = new Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor.ItemInserter("Record", () =>
{
AttributePropertyDescriptor desc = context.Descriptor as AttributePropertyDescriptor;
VariantMapList list = desc.lastReturn_ as VariantMapList;
if (list == null)
{
return(null);
}
VariantMapRecord rec = new VariantMapRecord(list);
list.Add(rec);
rec.Enabled = true;
return(rec);
});
List <Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor.ItemInserter> ret = new List <Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor.ItemInserter>();
ret.Add(inserter);
return(ret);
};
editor.RemoveItemFunc = (context, obj) =>
{
AttributePropertyDescriptor desc = context.Descriptor as AttributePropertyDescriptor;
VariantMapList list = desc.lastReturn_ as VariantMapList;
if (list == null)
{
return;
}
list.Remove(obj as VariantMapRecord);
UrhoBackend.VariantMap map = new UrhoBackend.VariantMap();
VariantMapRecord.Fill(map, list);
SetValue(context.LastSelectedObject, map);
};
return(editor);
}
else if (type_ == typeof(UrhoBackend.VariantVector))
{
Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor editor = new Sce.Atf.Controls.PropertyEditing.EmbeddedCollectionEditor();
return(editor);
}
else if (type_ == typeof(UrhoBackend.Quaternion))
{
return(new EditorCore.Controls.PropertyGrid.VectorEditor(typeof(UrhoBackend.Vector3), new[] { "X", "Y", "Z" }));
}
return(base.GetEditor(editorBaseType));
}
public override void SetValue(object component, object value)
{
UrhoBackend.Serializable wrapper = component as UrhoBackend.Serializable;
PropertyGridTypeHandler handler = component as PropertyGridTypeHandler;
if (handler != null && wrapper == null)
{
wrapper = handler.wrapper;
}
if (wrapper != null)
{
if (type_ == typeof(UrhoBackend.ResourceRef))
{
UrhoBackend.ResourceRef newRef = value as UrhoBackend.ResourceRef;
UrhoBackend.ResourceRef baseRef = wrapper.GetAttributeDefault(attrName_).GetResourceRef();
baseRef.SetResourceName(newRef.GetName());
wrapper.SetAttribute(attrName_, VariantTranslate.VariantFromObject(baseRef));
}
//else if (type_ == typeof(UrhoBackend.ResourceRefList))
//{
// List<string> list = value as List<string>;
// if (list != null)
// {
// UrhoBackend.ResourceRefList baseList = wrapper.GetAttributeDefault(attrName_).GetResourceRefList();
// baseList.FromList(list);
// wrapper.SetAttribute(attrName_, new UrhoBackend.Variant(baseList));
// }
//}
else if (attrInfo_.EnumNames != null && attrInfo_.EnumNames.Count > 0)
{
int index = attrInfo_.EnumNames.IndexOf(value.ToString());
wrapper.SetAttribute(attrName_, new UrhoBackend.Variant(index));
}
else if (type_ == typeof(UrhoBackend.Quaternion))
{
UrhoBackend.Vector3 vec3 = value as UrhoBackend.Vector3;
UrhoBackend.Quaternion quat = new UrhoBackend.Quaternion();
quat.FromEulerAngles(vec3.x, vec3.y, vec3.z);
wrapper.SetAttribute(attrName_, new UrhoBackend.Variant(quat));
}
else if (type_ == typeof(UrhoBackend.VariantMap))
{
VariantMapList records = lastReturn_ as VariantMapList; // value as VariantMapList;
UrhoBackend.VariantMap newMap = new UrhoBackend.VariantMap();
VariantMapRecord.Fill(newMap, records);
wrapper.SetAttribute(attrName_, new UrhoBackend.Variant(newMap));
VariableUtils.SetVariableNames(wrapper, records);
}
else if (type_ == typeof(UrhoBackend.VariantVector))
{
List <VariantVectorRecord> records = value as List <VariantVectorRecord>;
UrhoBackend.VariantVector newVec = new UrhoBackend.VariantVector();
VariantVectorRecord.To(newVec, records);
wrapper.SetAttribute(attrName_, new UrhoBackend.Variant(newVec));
}
else
{
wrapper.SetAttribute(attrName_, VariantTranslate.VariantFromObject(value));
}
}
//\todo
}
