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);
}
