public static Type GetLayerObject(LayersType obj) { switch (obj) { case LayersType.Range: return(typeof(Range_Item)); case LayersType.LinearScale: return(typeof(LinearScale_Item)); case LayersType.NumericScale: return(typeof(NumericScale_Item)); case LayersType.Label: return(typeof(Label_Item)); case LayersType.Arc: return(typeof(Arc_Item)); case LayersType.ClockHand: return(typeof(ClockHand_Item)); case LayersType.Ellipse: return(typeof(Ellipse_Item)); case LayersType.Rectangle: return(typeof(Rectangle_Item)); default: return(typeof(Range_Item)); } }
public void addNewLayer(Transform layerUIObject) { LayersType layerTypeToAdd = layerUIObject.GetComponentInChildren <LayerElementBehaviour>().layerType; GameObject newLayer = layerManager.prepareNewLayer(layerTypeToAdd); newLayer.transform.SetParent(layerStackParent); newLayer.transform.SetSiblingIndex(0); layerManager.StackUpdated(); }
private GameObject getUIDefinationFromType(LayersType type) { foreach (GameObject defination in layersDefinations) { if (defination.GetComponent <LayerElementBehaviour>().layerType == type) { return(Instantiate(defination)); } } return(null); }
public override bool Validate(LayersType below) { layerBelow = below; IRuleEngine <MultiplayLayer> ruleEngine = RuleEngineFactory <MultiplayLayer> .GetEngine(); var results = ruleEngine.Validate(this); foreach (var r in results) { if (r.IsBroken) { Debug.LogError(r.Name + " rule is broken and the error is " + r.ErrorMessage); } } return(results.Count == 0); }
public GameObject prepareNewLayer(LayersType type) { GameObject defination = getUIDefinationFromType(type); // get the UI defination prefab of current selected layer type. if (defination == null) { return(null); } GameObject container = Instantiate(layerContainerPrefab); // instantiat the defination container prefab. defination.transform.SetParent(container.transform); // add the UI defination as chiled of container. Layer tempLayer = Layer.getLayerOfType(type); // get the type of class from factory class. tempLayer.value = defination.GetComponent <LayerElementBehaviour>().getInputFieldValue(); // get the default Value of the layer. tempLayer.layerType = type; // set the type of the layer this should not be used if every thing work in drived classes. defination.GetComponent <LayerElementBehaviour>().ListNode = stackManager.AddNewLayer(tempLayer); // add the selected Layer type object to the Stack; return(container); // return the new Gameobject with selected type UI defination in a container. }
public static Layer getLayerOfType(LayersType type) { switch (type) { case LayersType.Addition: return(new AdditionLayer()); case LayersType.Subtraction: return(new SubtractionLayer()); case LayersType.Multiplication: return(new MultiplayLayer()); case LayersType.Division: return(new Layer()); case LayersType.None: return(new Layer()); default: return(new Layer()); } }
/// <summary> /// NOTE: overlapping definitions are not supported! /// If canvas and mergee have the same property set, the canvas property will be kept and the other ignored. /// Add support for resources with overlapping definitions if needed. /// </summary> /// <param name="otherDefinition"></param> public void Merge(ResourceDefinition otherDefinition) { // This is by convention - use meta from the layer, not from the canvas Meta = otherDefinition.Meta; foreach (var propInfo in DefinitionPropInfo) { var otherValue = propInfo.GetValue(otherDefinition, null); if (propInfo.Name == nameof(ObjectType)) { if (LayersType == null) { LayersType = new List <ObjectType>(); } LayersType.Add((ObjectType)otherValue); } if ((int)otherValue > 0 && (int)propInfo.GetValue(this, null) == 0) { propInfo.SetValue(this, otherValue, null); } } }
/// <summary>Creates optical metadata sidecar</summary> /// <param name="blockSize">Size of the read sector in bytes</param> /// <param name="blocks">Total number of positive sectors</param> /// <param name="mediaType">Disc type</param> /// <param name="layers">Disc layers</param> /// <param name="mediaTags">Media tags</param> /// <param name="sessions">Disc sessions</param> /// <param name="totalChkDuration">Total time spent doing checksums</param> /// <param name="discOffset">Disc write offset</param> void WriteOpticalSidecar(uint blockSize, ulong blocks, MediaType mediaType, LayersType layers, Dictionary <MediaTagType, byte[]> mediaTags, int sessions, out double totalChkDuration, int?discOffset) { _dumpLog.WriteLine("Creating sidecar."); var filters = new FiltersList(); IFilter filter = filters.GetFilter(_outputPath); IMediaImage inputPlugin = ImageFormat.Detect(filter); totalChkDuration = 0; if (!inputPlugin.Open(filter)) { StoppingErrorMessage?.Invoke("Could not open created image."); return; } DateTime chkStart = DateTime.UtcNow; // ReSharper disable once UseObjectOrCollectionInitializer _sidecarClass = new Sidecar(inputPlugin, _outputPath, filter.Id, _encoding); _sidecarClass.InitProgressEvent += InitProgress; _sidecarClass.UpdateProgressEvent += UpdateProgress; _sidecarClass.EndProgressEvent += EndProgress; _sidecarClass.InitProgressEvent2 += InitProgress2; _sidecarClass.UpdateProgressEvent2 += UpdateProgress2; _sidecarClass.EndProgressEvent2 += EndProgress2; _sidecarClass.UpdateStatusEvent += UpdateStatus; CICMMetadataType sidecar = _sidecarClass.Create(); DateTime end = DateTime.UtcNow; totalChkDuration = (end - chkStart).TotalMilliseconds; _dumpLog.WriteLine("Sidecar created in {0} seconds.", (end - chkStart).TotalSeconds); _dumpLog.WriteLine("Average checksum speed {0:F3} KiB/sec.", ((double)blockSize * (double)(blocks + 1)) / 1024 / (totalChkDuration / 1000)); if (_preSidecar != null) { _preSidecar.OpticalDisc = sidecar.OpticalDisc; sidecar = _preSidecar; } List <(ulong start, string type)> filesystems = new List <(ulong start, string type)>(); if (sidecar.OpticalDisc[0].Track != null) { filesystems.AddRange(from xmlTrack in sidecar.OpticalDisc[0].Track where xmlTrack.FileSystemInformation != null from partition in xmlTrack.FileSystemInformation where partition.FileSystems != null from fileSystem in partition.FileSystems select(partition.StartSector, fileSystem.Type)); } if (filesystems.Count > 0) { foreach (var filesystem in filesystems.Select(o => new { o.start, o.type }).Distinct()) { _dumpLog.WriteLine("Found filesystem {0} at sector {1}", filesystem.type, filesystem.start); } } sidecar.OpticalDisc[0].Dimensions = Dimensions.DimensionsFromMediaType(mediaType); (string type, string subType)discType = CommonTypes.Metadata.MediaType.MediaTypeToString(mediaType); sidecar.OpticalDisc[0].DiscType = discType.type; sidecar.OpticalDisc[0].DiscSubType = discType.subType; sidecar.OpticalDisc[0].DumpHardwareArray = _resume.Tries.ToArray(); sidecar.OpticalDisc[0].Sessions = (uint)sessions; sidecar.OpticalDisc[0].Layers = layers; if (discOffset.HasValue) { sidecar.OpticalDisc[0].Offset = (int)(discOffset / 4); sidecar.OpticalDisc[0].OffsetSpecified = true; } if (mediaTags != null) { foreach (KeyValuePair <MediaTagType, byte[]> tag in mediaTags.Where(tag => _outputPlugin. SupportedMediaTags. Contains(tag.Key))) { AddMediaTagToSidecar(_outputPath, tag, ref sidecar); } } UpdateStatus?.Invoke("Writing metadata sidecar"); var xmlFs = new FileStream(_outputPrefix + ".cicm.xml", FileMode.Create); var xmlSer = new XmlSerializer(typeof(CICMMetadataType)); xmlSer.Serialize(xmlFs, sidecar); xmlFs.Close(); }
public CompareLayerTypeAttribute(string name, string message, LayersType Below) : base(name, message) { layerTypeBelow = Below; }
public virtual bool Validate(LayersType below) { Debug.LogError("Base Class Reached Leyer Type Missing in setType function."); return(true); }