public SoundVisualizerVM(IValueHolderReadOnly<short[]> samples, IValueHolderReadOnly<int> samplingRate) { _color = new ValueHolder<Color>(); _samplingRate = samplingRate; _samples = samples; _frequencies = new ValueHolder<IReadOnlyList<KeyValuePair<Frequency, double>>>(); _amplitudes = new ValueHolder<IReadOnlyList<KeyValuePair<int, double>>>(); _averageIntensity = new ValueHolder<double>(); _averageAmplitudeFromLastSampling = new ValueHolder<double>(); Sound2ColorMappings = new List<ISound2ColorMapping>{ new LinearSound2ColorMapping{ Color = System.Windows.Media.Color.FromRgb(0,0,255), IntensityMultiplier = 0.8, SoundFrequencyMidpoint = new Frequency(250), SoundFrequencySpanWidth = new Frequency(300)}, new LinearSound2ColorMapping{ Color = System.Windows.Media.Color.FromRgb(0,255,0), IntensityMultiplier = 1.1, SoundFrequencyMidpoint = new Frequency(700), SoundFrequencySpanWidth = new Frequency(450)}, new LinearSound2ColorMapping{ Color = System.Windows.Media.Color.FromRgb(255,0,0), IntensityMultiplier = 0.9, SoundFrequencyMidpoint = new Frequency(1500), SoundFrequencySpanWidth = new Frequency(1000)}, new LinearSound2ColorMapping{ Color = System.Windows.Media.Color.FromRgb(255,0,0), IntensityMultiplier = 0.4, SoundFrequencyMidpoint = new Frequency(2600), SoundFrequencySpanWidth = new Frequency(1400)}}; _samples.PropertyChanged += HandleAmplitudesChanged; _samplingRate.PropertyChanged += HandleSamplingRateChanged; }
public MainWindow() { InitializeComponent(); _samples = new ValueHolder<short[]>(); _samplingRate = new ValueHolder<int>(); _soundManager = new SoundManager(); _soundManager.NewSamples += HandleNewSamples; _soundManager.StartRecording(0, 30); _samplingRate.Value = _soundManager.SamplingRate; _soundVisualizerVM = new SoundVisualizerVM(_samples, _samplingRate); _soundVisualizer = new SoundVisualizerControl(_soundVisualizerVM); //MainGrid.Children.Add(_soundVisualizer); _scene = new WPF3DScene(); MainGrid.Children.Add(_scene); _model = Create3DModel(); _scene.AddModel(_model); AddUIP3DPlane(); _soundVisualizerVM.AverageAmplitudeFromLastSampling.PropertyChanged += HandleAverageAmplitudeChanged; DeviceButton.Click += DeviceButton_Click; DeviceButton.Content = _soundManager.GetAvailableDevices().Keys.First().ProductName; }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string GetEnumName(this IValueHolder valueHolder, object key, bool uc, bool isMessage) /// /// \brief An IValueHolder extension method that gets enum name. /// /// \par Description. /// When getting a key this method returns the enum name of the key /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 22/10/2017 /// /// \param valueHolder The valueHolder to act on. /// \param key (object) - The key. /// \param uc (bool) - true to uc. /// \param isMessage (bool) - true if this object is message. /// /// \return The enum name. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string GetEnumName(this IValueHolder valueHolder, object key, bool uc) { string enumName = ""; if (key is NetworkElement.ElementDictionaries) { enumName = NetworkElement.ShortDictionariesNames[(int)((NetworkElement.ElementDictionaries)key)] + "k"; } else { string keyString = TypesUtility.GetKeyToString(key); if (uc) { enumName = char.ToUpper(keyString[0]) + keyString.Substring(1); } else { enumName = char.ToLower(keyString[0]) + keyString.Substring(1); } } return(enumName); }
private void FollowObjectReference(IValueHolder prop) { var refe = prop.Value as NdfObjectReference; if (refe == null) { return; } var vm = new NdfClassViewModel(refe.Class, ParentVm); var inst = vm.Instances.SingleOrDefault(x => x.Id == refe.InstanceId); if (inst == null) { return; } vm.InstancesCollectionView.MoveCurrentTo(inst); DialogProvider.ProvideView(vm, ParentVm); }
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) { if (context != null && context.Instance != null && provider != null) { IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)); if (edSvc != null) { IValueHolder ct = context.Instance as IValueHolder; if (ct != null) { Keys ks = (Keys)ct.Value; ControlSelectKeys csk = new ControlSelectKeys(); csk.SetEditorService(edSvc, ks); edSvc.DropDownControl(csk); if (csk.MadeSelection) { value = csk.Selection; } } } } return(value); }
public Number Calculate() { int steps = members.Count; var expr = new Queue <IFunctor>(members); while (steps-- > 0) { var member = expr.Dequeue(); if (member.Type == MemberType.Operand) { machine.Push(member.Calculate()); } else { var args = new IValueHolder[member.ParamsCount]; for (int i = args.Length - 1; i >= 0; i--) { args[i] = machine.Pop(); } try { machine.Push(member.SetInnerArgs(args).Calculate()); } catch (Exception ex) { throw new InvalidOperationException($"An exception occured during calculate an expression " + $"\"{InitialExpressionString}\" in variable set \"{VariableSet}\".\n" + $"Original exception is {ex}"); } } } return(machine.Pop().Value); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string MainDictionaryInitMethodName(this IValueHolder valueHolder) /// /// \brief An IValueHolder extension method that main dictionary init method name. /// /// \par Description. /// - The method name of the method that initializes a main dictionary /// - Example `InitPrivateAttribute` /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 22/10/2017 /// /// \param valueHolder The valueHolder to act on. /// /// \return A string. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string MainDictionaryInitMethodName(this IValueHolder valueHolder) { string dictionaryName = TypesUtility.GetKeyToString(valueHolder.Parent.GetChildKey(valueHolder)); return("Init" + dictionaryName); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static bool CheckIfBelongsToBaseAlgorithmEnum(this IValueHolder valueHolder, NetworkElement networkElement, NetworkElement.ElementDictionaries mainDictionary) /// /// \brief An IValueHolder extension method that determine if belongs to base algorithm enum. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 29/10/2017 /// /// \param valueHolder The valueHolder to act on. /// \param networkElement (NetworkElement) - The network element. /// \param mainDictionary (ElementDictionaries) - Dictionary of mains. /// /// \return True if the value holder belongs to the base network element. //////////////////////////////////////////////////////////////////////////////////////////////////// public static bool BelongsToBaseAlgorithmEnum(this IValueHolder valueHolder, NetworkElement networkElement, NetworkElement.ElementDictionaries mainDictionary) { // If the value holder is not attribute get the attribute of the value holder Attribute attribute; if (!(valueHolder is Attribute)) { attribute = (Attribute)valueHolder.Parent; } else { attribute = (Attribute)valueHolder; } // The condition is that the attribute which is the ancestor of our attribute // which is in the main dictionary belongs to the base class // Find the ancestor. // The parent sequence is ending in the following way // null <- networkElement <- Attribute <- mainDictionary <- Attribute // We have to find the last element in the chain described below // We do it with a loop that advances 2 parameters: The attribute and the chain end // The chain end is 4 times the parent of the attribute // Get the first chain end (If we cannot end the chain that means that the valueHolder is // one of the value holders at the middle of the chain hence they are not attributes in the // base classes main dictionary IValueHolder chainEnd = attribute; for (int idx = 0; idx < 4; idx++) { chainEnd = chainEnd.Parent; if (chainEnd == null && idx != 3) { return(false); } } // Find the ancestor while (chainEnd != null) { chainEnd = chainEnd.Parent.Parent; attribute = (Attribute)attribute.Parent.Parent; } // Decide if the attribute is part of the main dictionary if (!((AttributeDictionary)networkElement[mainDictionary]).Values.Any(a => a == attribute)) { return(false); } // Get the key of the attribute dynamic key = attribute.Parent.GetChildKey(attribute); if (TypesUtility.CompareDynamics(key, bn.ork.SingleStepStatus)) { int x = 1; } // Get the base NetworkElement Type baseNetworkElementType = networkElement.GetType().BaseType; NetworkElement baseNetworkElement = (NetworkElement)TypesUtility.CreateObjectFromTypeString(baseNetworkElementType.ToString()); baseNetworkElement.Init(0); // Check if the key is found in the base network element's dictionary return(((AttributeDictionary)baseNetworkElement[mainDictionary]).Keys.Any(k => TypesUtility.CompareDynamics(k, key))); }
private void GetValue(IValueHolder valueHolder, NdfObjectViewModel inst, List<NdfPropertyValue> result, NdfPropertyValue propertyValue) { switch (valueHolder.Value.Type) { case NdfType.ObjectReference: var ndfObjectReference = valueHolder.Value as NdfObjectReference; if (ndfObjectReference != null && ndfObjectReference.InstanceId == inst.Object.Id) result.Add(propertyValue); break; case NdfType.List: case NdfType.MapList: var ndfCollection = valueHolder.Value as NdfCollection; if (ndfCollection != null) foreach (var col in ndfCollection) GetValue(col, inst, result, propertyValue); break; case NdfType.Map: var map = valueHolder.Value as NdfMap; if (map != null) { GetValue(map.Key, inst, result, propertyValue); GetValue(map.Value as IValueHolder, inst, result, propertyValue); } break; } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public override void SetMembers(BaseNetwork network, NetworkElement element, Permissions permissions, IValueHolder parent, bool recursive = true) /// /// \brief Sets the members. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 30/05/2018 /// /// \param network (BaseNetwork) - The network. /// \param element (NetworkElement) - The element. /// \param permissions (Permissions) - The permissions. /// \param parent (IValueHolder) - The parent. /// \param recursive (Optional) (bool) - true to process recursively, false to process locally only. //////////////////////////////////////////////////////////////////////////////////////////////////// public override void SetMembers(BaseNetwork network, NetworkElement element, Permissions permissions, IValueHolder parent, bool recursive = true) { base.SetMembers(network, element, permissions, parent); process = (BaseProcess)Element; }
private void FollowDetails(IValueHolder prop) { if (prop == null || prop.Value == null) return; switch (prop.Value.Type) { case NdfType.MapList: case NdfType.List: FollowList(prop); break; case NdfType.ObjectReference: FollowObjectReference(prop); break; case NdfType.Map: var map = prop.Value as NdfMap; if (map != null) { FollowDetails(map.Key); FollowDetails(map.Value as IValueHolder); } break; default: return; } }
private void FollowObjectReference(IValueHolder prop) { var refe = prop.Value as NdfObjectReference; if (refe == null) return; var vm = new NdfClassViewModel(refe.Class, null); NdfObjectViewModel inst = vm.Instances.SingleOrDefault(x => x.Id == refe.InstanceId); if (inst == null) return; vm.InstancesCollectionView.MoveCurrentTo(inst); DialogProvider.ProvideView(vm); }
public TestController(IValueHolder valueHolder) { _valueHolder = valueHolder; }
public static IFunctor Wrap(IValueHolder valueHolder) => new VoidFunctor().SetInnerArgs(new IValueHolder[] { valueHolder });
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static void GenerateCheckMessage(this IValueHolder valueHolder, int nestingLevel, string key, string message) /// /// \brief Generates a check message. /// /// \par Description. /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 25/07/2017 /// /// \param valueHolder The valueHolder to act on. /// \param nestingLevel (int) - The nesting level. /// \param key (string) - The key. /// \param message (string) - The message. //////////////////////////////////////////////////////////////////////////////////////////////////// public static void GenerateCheckMessage(this IValueHolder valueHolder, int nestingLevel, string key, string message) { MessageRouter.ReportMessage(new string('\t', nestingLevel) + "[" + key + "] (" + valueHolder.GetType().ToString().Replace("DistributedAlgorithms.", "") + ") ", "", message); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static bool EqualsTo(this IValueHolder valueHolder, int nestingLevel, object key, IValueHolder other, bool checkNotSameObject = false) /// /// \brief Equals to. /// /// \par Description. /// - This method recursively checks if the first IValueHolder is equal to the second /// - The compare is for the values and not the pointers of the IValueHolder /// - The parameter checkNotSameObject is for checking that there was a copy (means created /// new objects) and not assignments. /// /// \par Algorithm. /// -# Common checks for all the IValueHolder /// -# The type of the 2 IValueHolder is the same /// -# If checkNotSameObject check that the objects are not the same objects /// -# Activate the recursive compare by calling the IValueHolder's EqualsTo method. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 25/07/2017 /// /// \param valueHolder The valueHolder to act on. /// \param nestingLevel (int) - The nesting level. /// \param key (object) - The key. /// \param other (IValueHolder) - The other. /// \param checkNotSameObject (Optional) (bool) - true to check not same object. /// /// \return True if equals to, false if not. //////////////////////////////////////////////////////////////////////////////////////////////////// public static bool CheckEqual(this IValueHolder valueHolder, int nestingLevel, object key, IValueHolder other, bool print = false, bool checkNotSameObject = false) { string keyString = TypesUtility.GetKeyToString(key); if (print) { if (nestingLevel == 0) { MessageRouter.ReportMessage("----- Start EqualsTo -----", "", ""); } valueHolder.GenerateCheckMessage(nestingLevel, keyString, " Start"); } if (!valueHolder.GetType().Equals(other.GetType())) { valueHolder.GenerateCheckMessage(nestingLevel, keyString, "The type of one is : " + valueHolder.GetType() + " The type of two is : " + other.GetType()); return(false); } if (checkNotSameObject) { if (valueHolder == other) { valueHolder.GenerateCheckMessage(nestingLevel, keyString, "The pointer of one and two is equal and it should not"); return(false); } } string error = ""; if (valueHolder.EqualsTo(nestingLevel, ref error, other, print, checkNotSameObject)) { if (print) { if (nestingLevel == 0) { MessageRouter.ReportMessage("----- Start EqualsTo -----", "", ""); } valueHolder.GenerateCheckMessage(nestingLevel, keyString, " End - True"); } return(true); } else { if (print) { valueHolder.GenerateCheckMessage(nestingLevel, keyString, " " + error); valueHolder.GenerateCheckMessage(nestingLevel, keyString, " End - False"); if (nestingLevel == 0) { MessageRouter.ReportMessage("----- End EqualsTo -----", "", ""); } } return(false); } }
public SynchronizedDecorator(IValueHolder <T> vh) => this.vh = vh;
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string MainDictionaryName(this IValueHolder valueHolder) /// /// \brief An IValueHolder extension method that main dictionary name. /// /// \par Description. /// - Get the name of the main dictionary. /// - The name of the main dictionary is the name of the enum for that dictionary without /// the last letter (for example for PrivateAttribute dictionary the enum name is pak /// and the dictionary name is pa) /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 22/10/2017 /// /// \param valueHolder The valueHolder to act on. /// /// \return A string. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string MainDictionaryName(this IValueHolder valueHolder) { string keyString = valueHolder.GetEnumName((object)valueHolder.Parent.GetChildKey(valueHolder), false); return(keyString.Substring(0, keyString.Length - 1)); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string InitMethodName(this IValueHolder valueHolder) /// /// \brief An IValueHolder extension method that init method name. /// /// \par Description. /// - Method name for methods used in the init phase. /// - Example : `Init_EnumName` /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 22/10/2017 /// /// \param valueHolder The valueHolder to act on. /// /// \return A string. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string InitMethodName(this IValueHolder valueHolder) { return("Init_" + valueHolder.GetKeyString(true)); }
public SingleOptionControl(IValueHolder <string> optionRef, OptionsList list, string nameForLogging, IWritingSystemDefinition preferredWritingSystem) : this(optionRef, list, nameForLogging, preferredWritingSystem, null) { }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string SendMethodName(this IValueHolder valueHolder, object key) /// /// \brief An IValueHolder extension method that sends a method name. /// /// \par Description. /// - Method name for sending a message method /// - Example : `SendMessageName` /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 22/10/2017 /// /// \param valueHolder The valueHolder to act on. /// \param key (object) - The key. /// /// \return A string. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string SendMethodName(this IValueHolder valueHolder, object key) { return("Send" + valueHolder.GetEnumName(key, true)); }
private void FollowList(IValueHolder prop) { var refe = prop.Value as NdfCollection; if (refe == null) return; var editor = new ListEditorViewModel(refe, NdfbinManager); DialogProvider.ProvideView(editor, this); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public static string MessageMainDictionaryMethodName(this IValueHolder valueHolder, dynamic key) /// /// \brief An IValueHolder extension method that message main dictionary method name. /// /// \par Description. /// Main dictionary method name (To be used in the generation of the Send... method /// /// \par Algorithm. /// /// \par Usage Notes. /// /// \author Ilanh /// \date 24/12/2017 /// /// \param valueHolder The valueHolder to act on. /// \param key (dynamic) - The key. /// /// \return A string. //////////////////////////////////////////////////////////////////////////////////////////////////// public static string MessageMainDictionaryMethodName(this IValueHolder valueHolder, object key) { return("MessageDataFor_" + valueHolder.GetEnumName(key, true)); }
public LogDecorator(IValueHolder<T> vh, TextWriter output) { this.vh = vh; this.output = output; }
private NdfValueWrapper GetCopiedValue(IValueHolder toCopy) { NdfValueWrapper copiedValue = null; switch (toCopy.Value.Type) { case NdfType.ObjectReference: var origInst = toCopy.Value as NdfObjectReference; if (origInst != null && !origInst.Instance.IsTopObject) copiedValue = new NdfObjectReference(origInst.Class, CopyInstance(origInst.Instance).Id); else copiedValue = NdfTypeManager.GetValue(toCopy.Value.GetBytes(), toCopy.Value.Type, toCopy.Manager); break; case NdfType.List: case NdfType.MapList: var copiedItems = new List<CollectionItemValueHolder>(); var collection = toCopy.Value as NdfCollection; if (collection != null) copiedItems.AddRange(collection.Select(entry => new CollectionItemValueHolder(GetCopiedValue(entry), toCopy.Manager))); copiedValue = new NdfCollection(copiedItems); break; case NdfType.Map: var map = toCopy.Value as NdfMap; if (map != null) copiedValue = new NdfMap(new MapValueHolder(GetCopiedValue(map.Key), toCopy.Manager), new MapValueHolder(GetCopiedValue(map.Value as IValueHolder), toCopy.Manager), toCopy.Manager); break; default: copiedValue = NdfTypeManager.GetValue(toCopy.Value.GetBytes(), toCopy.Value.Type, toCopy.Manager); break; } return copiedValue; }