public void CanParseNestedObjectWithInheritance()
{
const string input =
"myType MyObject : InheritedObject\n" +
"{\n" +
" myNestedType MyNestedObject : InheritedObject\n" +
" {\n" +
" include paths = \"./\"\n" +
" }\n" +
"}";
ObjectElement obj = DocumentParser.NamedObject.Parse(input);
Assert.NotNull(obj);
Assert.Single(obj.Children);
ConfigElement element = obj.Children.FirstOrDefault();
Assert.NotNull(element);
Assert.IsType <ObjectElement>(element);
var nestedObj = (ObjectElement)element;
Assert.Equal("myNestedType", nestedObj.Heading.Type);
Assert.Equal("MyNestedObject", nestedObj.Heading.Name);
Assert.Single(nestedObj.Children);
}
public virtual ObjectElement GetRootSyncObject()
{
global::System.IntPtr cPtr = SharingClientPINVOKE.SharingManager_GetRootSyncObject(swigCPtr);
ObjectElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectElement(cPtr, true);
return(ret);
}
public void CanParseObjectWithSimpleCommands()
{
const string input =
"myType MyObject : InheritedObject\n" +
"{\n" +
" if (no-tests) exclude\n" +
" if (!test) skip\n" +
"}";
string[] expectedNames =
{
"exclude", "skip"
};
ObjectElement obj = DocumentParser.NamedObject.Parse(input);
Assert.NotNull(obj);
Assert.Equal(2, obj.Children.Count());
for (int i = 0; i < 2; i++)
{
var cmd = obj.Children.ElementAt(i) as CommandElement;
Assert.NotNull(cmd);
Assert.Equal(expectedNames[i], cmd.CommandName);
}
}
public virtual ObjectElement CreateObjectElement(XString name, User owner)
{
global::System.IntPtr cPtr = SharingClientPINVOKE.ObjectElement_CreateObjectElement__SWIG_0(swigCPtr, XString.getCPtr(name), User.getCPtr(owner));
ObjectElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectElement(cPtr, true);
return(ret);
}
public void Add(ObjectElement obj, IEnumerable <ColumnElement> columns)
{
var className = SafeName(string.IsNullOrEmpty(obj.ClassName) ? obj.Name : obj.ClassName);
var propertyName = SafeName(string.IsNullOrEmpty(obj.PropertyName) ? obj.Name : obj.PropertyName);
if (IsPluralize)
{
className = Pluralization.Singularize(className);
propertyName = Pluralization.Pluralize(propertyName);
}
var objectGenerator = new ClassGenerator(obj)
{
ClassName = className,
PropertyName = propertyName
};
foreach (var column in columns)
{
var name = SafeName(string.IsNullOrEmpty(column.PropertyName) ? column.Name : column.PropertyName);
if (objectGenerator.ClassName == name)
{
name += CharIndex;
}
var memberGenerator = new MemberGenerator(column, name);
objectGenerator.Members.Add(column.Name, memberGenerator);
}
Objects.Add(obj.Key, objectGenerator);
}
public virtual ObjectElement CreateObjectElement(XString name, XString objectType)
{
System.IntPtr cPtr = SharingClientPINVOKE.ObjectElement_CreateObjectElement__SWIG_1(swigCPtr, XString.getCPtr(name), XString.getCPtr(objectType));
ObjectElement ret = (cPtr == System.IntPtr.Zero) ? null : new ObjectElement(cPtr, true);
return(ret);
}
/// <summary>
/// Adds a new entry into the array.
/// </summary>
/// <param name="newSyncObject">New object to add.</param>
/// <param name="owner">Owner the object. Set to null if the object has no owner.</param>
/// <returns>Object that was added, with its networking elements setup.</returns>
public T AddObject(T newSyncObject, User owner = null)
{
string id = null;
// Create our object element for our target
id = System.Guid.NewGuid().ToString();
string dataModelName = SyncSettings.Instance.GetDataModelName(newSyncObject.GetType());
ObjectElement existingElement = this.Element.CreateObjectElement(new XString(id), dataModelName, owner);
// Create a new object and assign the element
newSyncObject.Element = existingElement;
newSyncObject.FieldName = id;
newSyncObject.Owner = owner;
// Register the child with the object
AddChild(newSyncObject);
// Update internal map
this.dataArray[id] = newSyncObject;
// Initialize it so it can be used immediately.
newSyncObject.InitializeLocal(Element);
// Notify listeners that an object was added.
if (ObjectAdded != null)
{
ObjectAdded(newSyncObject);
}
return(newSyncObject);
}
public static ObjectElement Cast(Element element)
{
System.IntPtr cPtr = SharingClientPINVOKE.ObjectElement_Cast(Element.getCPtr(element));
ObjectElement ret = (cPtr == System.IntPtr.Zero) ? null : new ObjectElement(cPtr, true);
return(ret);
}
protected DuplicateObjectNameException(string objectType, ObjectElement newElement, ObjectElement existingElement)
: base(string.Format("{0} object with name '{1}' has already been defined:\n" +
"Existing object:\n{2}\n" +
"Duplicate object:\n{3}",
objectType, newElement.Heading.Name, existingElement, newElement))
{
}
public void ParseElements()
{
foreach (ConfigElement element in configDoc.Children)
{
if (element is ObjectElement obj)
{
if (obj.Heading.Type.Equals(SectionType.SOLUTION, StringComparison.OrdinalIgnoreCase))
{
SolutionElement = obj;
}
else if (obj.Heading.Type.Equals(SectionType.MODULE, StringComparison.OrdinalIgnoreCase))
{
moduleElements.Add(obj);
}
else if (obj.Heading.Type.Equals(SectionType.TEMPLATE, StringComparison.OrdinalIgnoreCase))
{
templateElements.Add(obj);
}
else
{
throw new InvalidObjectType(obj,
SectionType.SOLUTION, SectionType.MODULE, SectionType.TEMPLATE);
}
}
}
}
public void CanParseNestedChildrenWithInheritance()
{
const string input =
"myType MyObject : InheritedObject\n" +
"{\n" +
" myNestedType My.NestedObject1 : InheritedObject\n" +
" {\n" +
" }\n" +
" myNestedType My.NestedObject2 : InheritedObject\n" +
" {\n" +
" }\n" +
"}";
ObjectElement root = DocumentParser.NamedObject.Parse(input);
Assert.NotNull(root);
Assert.Equal(2, root.Children.Count());
for (int i = 1; i <= 2; i++)
{
string expectedName = $"My.NestedObject{i}";
ConfigElement element = root.Children.ElementAtOrDefault(i - 1);
Assert.NotNull(element);
Assert.IsType <ObjectElement>(element);
var obj = (ObjectElement)element;
Assert.Equal("myNestedType", obj.Heading.Type);
Assert.Equal(expectedName, obj.Heading.Name);
Assert.Equal("InheritedObject", obj.Heading.InheritedObjectName);
}
}
public Result Read(ObjectElement moduleElement)
{
Log.Heading("Reading module element: {0}", moduleElement);
Result result;
using (new CompositeDisposable(
new Log.ScopedIndent(),
new Log.ScopedTimer(Log.Level.Debug, "Read Module", moduleElement)))
{
string moduleName = moduleElement.Heading.Name;
string templateName = moduleElement.Heading.InheritedObjectName;
excludedProjects = new HashSet <string>();
idLookup = new Dictionary <string, Project.Identifier>();
if (!string.IsNullOrEmpty(templateName) && !templates.ContainsKey(templateName))
{
throw new UndefinedTemplateException(templateName);
}
Template template = templateReader.Read(moduleElement);
using (new ExpandableVars.ScopedVariable(ExpandableVars.Instance, ExpandableVars.VAR_MODULE_NAME,
moduleName))
{
Dictionary <Configuration, ModuleConfiguration> moduleConfigs =
CreateModuleConfigs(template, moduleName);
result = new Result(new Module(solution, moduleName, moduleConfigs, idLookup), excludedProjects);
}
}
return(result);
}
public SolutionReader(ObjectElement solutionElement, string solutionConfigDir, bool loadIncludes)
{
Log.Heading("Reading solution element: {0}", solutionElement);
using (new Log.ScopedIndent())
{
if (ExpandableVars.Instance == null)
{
throw new InvalidOperationException("ExpandableVars are null");
}
ExpandableVars.Instance.SetExpandableVariable(ExpandableVars.VAR_SOLUTION_NAME,
solutionElement.Heading.Name);
ExpandableVars.Instance.SetExpandableVariable(ExpandableVars.VAR_CONFIG_DIR, solutionConfigDir);
settingsReader = new SolutionSettingsReader(ExpandableVars.Instance.Variables);
Settings settings = settingsReader.Read(solutionElement);
Solution = new Solution(solutionElement.Heading.Name, settings, solutionConfigDir,
GetConfigurationGroups(settings), new FileUtil.ResultCache());
ExpandableVars.Instance.SetExpandableVariable(ExpandableVars.VAR_SOLUTION_PATH,
Path.Combine(Solution.OutputDir, solutionElement.Heading.Name + ".sln"));
ObjectElement settingsElement = solutionElement.Children
.OfType <ObjectElement>()
.FirstOrDefault(obj => obj.Heading.Type == SectionType.SETTINGS &&
obj.Heading.Name == DEFAULT_TEMPLATE_SETTINGS);
if (settingsElement == null)
{
Log.Info(
"No settings named '{0}' found in solution element. " +
"Templates will use hard coded defaults instead.",
DEFAULT_TEMPLATE_SETTINGS);
TemplateDefaultSettings = settingsReader.GetDefaultSettings();
}
else
{
Log.Info(
"Settings named '{0}' found in solution element. " +
"Templates will default to the settings read below.",
DEFAULT_TEMPLATE_SETTINGS);
using (new Log.ScopedIndent())
{
TemplateDefaultSettings =
new ProjectSettingsReader(ExpandableVars.Instance.Variables)
.Read(settingsElement);
}
}
if (loadIncludes)
{
LoadIncludes();
}
}
}
public Template(string name, ObjectElement sourceElement,
IReadOnlyDictionary <string, ObjectElement> settingsSourceElements,
IReadOnlyDictionary <Configuration, TemplateConfiguration> configurations)
{
Name = name;
SourceElement = sourceElement;
SettingsSourceElements = settingsSourceElements;
Configurations = configurations;
}
public void CanParseEmptyObjectWithInheritance(string input)
{
ObjectElement obj = DocumentParser.NamedObject.Parse(input);
Assert.NotNull(obj);
Assert.Equal("myType", obj.Heading.Type);
Assert.Equal("MyObject", obj.Heading.Name);
Assert.Equal("MyOtherType", obj.Heading.InheritedObjectName);
}
private void CleanupNetworkObjects()
{
if (networkMessageLoop != null)
{
networkMessageLoop.Dispose();
networkMessageLoop = null;
}
if (this.rootObject != null)
{
this.rootObject.RemoveListener(this.syncListener);
this.rootObject.Dispose();
this.rootObject = null;
}
if (this.syncListener != null)
{
this.syncListener.Dispose();
this.syncListener = null;
}
if (viewerConnection != null)
{
viewerConnection.RemoveListener((byte)MessageID.StatusOnly, ViewerListener);
viewerConnection.Disconnect();
this.viewerConnection.Dispose();
this.viewerConnection = null;
}
if (serverConnection != null)
{
serverConnection.RemoveListener((byte)MessageID.StatusOnly, ServerListener);
serverConnection.Disconnect();
this.serverConnection.Dispose();
this.serverConnection = null;
}
if (this.SessionManager != null)
{
this.SessionManager.RemoveListener(this.SessionManagerListener);
this.SessionManager.Dispose();
this.SessionManager = null;
}
if (this.SessionManagerListener != null)
{
this.SessionManagerListener.Dispose();
this.SessionManagerListener = null;
}
if (SharingManager != null)
{
SharingManager.Dispose();
SharingManager = null;
}
}
public XdRenderer(XdArtboard xdArtboard, XdAssetHolder xdAssetHolder, IXdObjectParser[] objectParsers, IXdGroupParser[] groupParsers, AkyuiXdImportTrigger[] triggers)
{
var resources = xdArtboard.Resources;
_xdAssetHolder = xdAssetHolder;
_objectParsers = objectParsers;
_groupParsers = groupParsers;
Elements = new List <IElement>();
Assets = new List <IAsset>();
_obbHolder = new ObbHolder();
CreateRefObjectMap(resources.Resources);
var xdResourcesArtboardsJson = resources.Artboards[xdArtboard.Manifest.Path.Replace("artboard-", "")];
var rootObb = new Obb {
Size = new Vector2(xdResourcesArtboardsJson.Width, xdResourcesArtboardsJson.Height)
};
var rootArtboard = xdArtboard.Artboard.Children[0];
var xdObjectJsons = rootArtboard.Artboard.Children;
var convertedXdObjectJsons = ConvertRefObject(xdObjectJsons, triggers);
var childrenObbs = CalcPosition(convertedXdObjectJsons, rootObb);
foreach (var childObb in childrenObbs)
{
childObb.LocalLeftTopPosition -= new Vector2(xdResourcesArtboardsJson.X, xdResourcesArtboardsJson.Y);
}
var children = Render(convertedXdObjectJsons, rootObb);
var rootComponents = new List <IComponent>();
if (rootArtboard.Style?.Fill != null && rootArtboard.Style.Fill.Type == "solid")
{
var color = rootArtboard.GetFillUnityColor();
rootComponents.Add(new ImageComponent(null, color, Vector2Int.one));
}
var root = new ObjectElement(
0,
xdArtboard.Name,
Vector2.zero,
rootObb.Size,
AnchorXType.Center,
AnchorYType.Middle,
0f,
true,
rootComponents.ToArray(),
children.Select(x => x.Eid).ToArray()
);
Elements.Add(root);
}
public static void AddObjectElement(string _uuid, string _alias, Sprite _icon)
{
if (objectElements.ContainsKey(_uuid))
{
return;
}
ObjectElement obj = new ObjectElement();
obj.uuid = _uuid;
obj.alias = _alias;
obj.icon = _icon;
objectElements[_uuid] = obj;
}
private void CreateSyncListener(ObjectElement element)
{
// Create a listener for this
syncListener = new ObjectElementAdapter();
syncListener.ElementAddedEvent += OnElementAdded;
syncListener.ElementDeletedEvent += OnElementDeleted;
syncListener.BoolChangedEvent += OnBoolElementChanged;
syncListener.IntChangedEvent += OnIntElementChanged;
syncListener.LongChangedEvent += OnLongElementChanged;
syncListener.FloatChangedEvent += OnFloatElementChanged;
syncListener.DoubleChangedEvent += OnDoubleElementChanged;
syncListener.StringChangedEvent += OnStringElementChanged;
element.AddListener(syncListener);
}
/// <summary>
/// Remove a child primitive that belongs to this object.
/// </summary>
/// <param name="data">Sync Primitive Data</param>
protected void RemoveChild(SyncPrimitive data)
{
// Manually remove from maps
if (primitives.Remove(data) && data.HasNetworkElement)
{
primitiveMap.Remove(data.NetworkElement.GetGUID());
// Object has been removed internally, notify network
ObjectElement parentElement = ObjectElement.Cast(data.NetworkElement.GetParent());
if (parentElement != null)
{
parentElement.RemoveElement(data.NetworkElement);
}
}
}
public void CanParseObjectWhereNameStartsWithPropertyAction()
{
// "settings" should not be interpreted as the start of a property.
const string input =
"settings MyObject : InheritedObject\n" +
"{\n" +
" settings MyNestedObject : InheritedObject\n" +
" {\n" +
" }\n" +
"}";
ObjectElement root = DocumentParser.NamedObject.Parse(input);
Assert.NotNull(root);
}
protected override void OnElementAdded(Element element)
{
if (element.GetElementType() == ElementType.ObjectType)
{
// Add the new object and listen for when the initialization has fully completed since it can take time.
T newObject = AddObject(ObjectElement.Cast(element));
newObject.InitializationComplete += OnInitializationComplete;
}
else
{
Debug.LogError("Error: Adding unknown element to SyncArray<T>");
}
base.OnElementAdded(element);
}
/// <summary>
/// Adds a new entry into the array.
/// </summary>
/// <param name="existingElement">Element from which the object should be created.</param>
/// <returns></returns>
private T AddObject(ObjectElement existingElement)
{
string id = existingElement.GetName();
// Create a new object and assign the element
T newObject = CreateObject(existingElement);
// Register the child with the object
AddChild(newObject);
// Update internal map
dataArray[id] = newObject;
return(newObject);
}
/// <summary>
/// Initializes a new object element.
/// </summary>
/// <param name="name">The name to consider.</param>
/// <param name="id">The ID to consider.</param>
/// <param name="classFullName">The class full name to consider.</param>
/// <param name="items">The items to consider.</param>
public static ObjectElement CreateObject(
string name,
string id,
string classFullName,
params object[] items)
{
ObjectElement element = new ObjectElement(name, id)
{
ClassFullName = classFullName,
};
element.WithItems(items);
return(element);
}
private Task <ModuleReader.Result> ReadModuleAsync(ObjectElement moduleElement)
{
var reader = new ModuleReader(Solution, Templates, templateReader);
var baseVars = new Dictionary <string, string>(ExpandableVars.Instance.Variables);
int indentLevel = Log.Instance.IndentLevel;
return(Task.Run(() =>
{
using (new Log.BufferedTaskOutput("RM-" + moduleElement.Heading.Name, indentLevel))
{
ExpandableVars.Init(baseVars);
ModuleReader.Result moduleResult = reader.Read(moduleElement);
return moduleResult;
}
}));
}
private string ParseObject(ElementBase element)
{
ObjectElement obj = (ObjectElement)element;
string r = "{" + obj.Guid.ToString() + "}";
r += "#" + obj.Version;
r += "#";
if (obj.Reserved != null)
{
r += obj.Reserved;
}
r += obj.Name;
return(r);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>True</c> to release both managed and unmanaged resources; <c>False</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
if (this.syncListener != null)
{
this.syncListener.Dispose();
this.syncListener = null;
}
if (this.viewerConnection != null)
{
this.viewerConnection.Dispose();
this.viewerConnection = null;
}
if (this.serverConnection != null)
{
this.serverConnection.Dispose();
this.serverConnection = null;
}
if (this.rootObject != null)
{
this.rootObject.Dispose();
this.rootObject = null;
}
if (this.SessionManager != null)
{
this.SessionManager.Dispose();
this.SessionManager = null;
}
if (this.Manager != null)
{
this.Manager.Dispose();
this.Manager = null;
}
}
this.disposed = true;
}
}
public void DrawList()
{
InfoObjects_flowLayoutPanel.Controls.Clear();
int i = 1;
foreach (var ObjectElement in listOfObjects)
{
Label lbl = new Label();
lbl.Visible = true;
lbl.Text = ("№" + i.ToString() + " " + ObjectElement.GetType().Name);
lbl.Name = ObjectElement.GetType().Name + "_Label";
lbl.Font = new Font("Microsoft Sans Serif", 14, FontStyle.Regular);
lbl.Width = 550;
InfoObjects_flowLayoutPanel.Controls.Add(lbl);
DrawFields(ObjectElement);
i++;
}
}
/// <summary>
/// Creates the object in the array, based on its underlying object element that came from the sync system.
/// </summary>
/// <param name="objectElement">Object element on which the data model object is based.</param>
/// <returns>The created data model object of the appropriate type.</returns>
protected virtual T CreateObject(ObjectElement objectElement)
{
Type objectType = SyncSettings.Instance.GetDataModelType(objectElement.GetObjectType()).AsType();
if (!objectType.IsSubclassOf(arrayType) && objectType != arrayType)
{
throw new InvalidCastException(string.Format("Object of incorrect type added to SyncArray: Expected {0}, got {1} ", objectType, objectElement.GetObjectType().GetString()));
}
object createdObject = Activator.CreateInstance(objectType);
T spawnedDataModel = (T)createdObject;
spawnedDataModel.Element = objectElement;
spawnedDataModel.FieldName = objectElement.GetName();
// TODO: this should not query SharingStage, but instead query the underlying session layer
spawnedDataModel.Owner = SharingStage.Instance.SessionUsersTracker.GetUserById(objectElement.GetOwnerID());
return(spawnedDataModel);
}
public List <ObjectElement> GetObjects()
{
var xmlObjectGroup = xrootElement.Elements("objectgroup");
List <ObjectElement> objects = new List <ObjectElement>();
foreach (var objectGroup in xmlObjectGroup)
{
foreach (var objectElement in objectGroup.Elements("object"))
{
ObjectElement objectsElement = new ObjectElement();
objectsElement.id = (int)objectElement.Attribute("id");
objectsElement.xpos = (int)objectElement.Attribute("x");
objectsElement.ypos = (int)objectElement.Attribute("y");
objectsElement.width = (int)objectElement.Attribute("width");
objectsElement.height = (int)objectElement.Attribute("height");
objects.Add(objectsElement);
}
}
return(objects);
}
/// <summary>
/// Constructor
/// Creates a MappingModelHasObjectElements link in the same Partition as the given MappingModel
/// </summary>
/// <param name="source">MappingModel to use as the source of the relationship.</param>
/// <param name="target">ObjectElement to use as the target of the relationship.</param>
public MappingModelHasObjectElements(MappingModel source, ObjectElement target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(MappingModelHasObjectElements.MappingModelDomainRoleId, source), new DslModeling::RoleAssignment(MappingModelHasObjectElements.ElementDomainRoleId, target)}, null)
{
}
public ObjectInspectorData (object target)
{
this.target = target;
this.targetType = target != null ? target.GetType () : typeof(object);
IsList = (target is IList) || (target is IDictionary);
if (IsList) {
Properties = new ObjectProperty[0];
Hierarchy = new Type[0];
} else {
var props = targetType.GetProperties ().
Where (x =>
x.GetIndexParameters ().Length == 0 &&
x.GetMethod != null &&
!x.GetMethod.IsStatic).
Select (GetObjectPropertyFromProperty);
var fields = targetType.GetFields ().
Where (x =>
!x.IsStatic).
Select (GetObjectPropertyFromField);
Properties = fields.Concat (props).OrderBy (x => x.Name).ToArray ();
var h = new List<Type> ();
h.Add (this.targetType);
while (h [h.Count - 1] != typeof(object)) {
var bt = h [h.Count - 1].BaseType;
if (bt != null) {
h.Add (bt);
} else {
break;
}
}
h.Remove (this.targetType);
h.Remove (typeof(object));
h.Remove (typeof(ValueType));
Hierarchy = h.ToArray ();
}
var elementMax = 1000;
if (this.target is IDictionary) {
var res = new List<ObjectElement> ();
IDictionaryEnumerator de = ((IDictionary)this.target).GetEnumerator ();
while (res.Count < elementMax && de.MoveNext ()) {
res.Add (new ObjectElement {
Title = string.Format ("{0}: {1}", de.Key, de.Value),
Value = de.Value,
});
}
Elements = res.ToArray ();
} else {
var ie = this.target as IEnumerable;
if (ie != null && !(this.target is string)) {
try {
Elements = ie.Cast<object> ().Take (elementMax).Select ((x, i) => new ObjectElement {
Title = string.Format ("{0}: {1}", i, x),
Value = x,
}).ToArray ();
} catch (Exception ex) {
Log (ex);
}
}
}
if (Elements == null) {
Elements = new ObjectElement[0];
}
Title = this.targetType.Name;
if (target == null) {
ToStringValue = "null";
HashDisplayString = "#0";
}
else {
try {
ToStringValue = target.ToString ();
} catch (Exception ex) {
ToStringValue = ex.ToString ();
Log (ex);
}
try {
HashDisplayString = "#" + target.GetHashCode ();
} catch (Exception ex) {
HashDisplayString = ex.ToString ();
Log (ex);
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ObjectElement obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public static void SetMappingModel(ObjectElement element, MappingModel newMappingModel)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, ElementDomainRoleId, newMappingModel);
}
public static MappingModel GetMappingModel(ObjectElement element)
{
return DslModeling::DomainRoleInfo.GetLinkedElement(element, ElementDomainRoleId) as MappingModel;
}
