/// <summary>
/// Returns the currently stored set of Api Keys
/// </summary>
/// <returns></returns>
public ObservableConcurrentDictionary <string, string> GetKeys()
{
//Deserialize the ApiKeys
this.ApiKeys = JsonConvert.DeserializeObject <ObservableConcurrentDictionary <string, string> >(this.Keys);
return(this.ApiKeys);
}
private NeighborProtocol()
{
Neighbors = new ObservableConcurrentDictionary <string, Neighbor>();
settings = Settings.GetInstance;
senderEvent = new ManualResetEvent(settings.Online);
address = App.CheckInterfaces();
listener = new Thread(Listen)
{
Name = "listener",
IsBackground = true
};
listener.Start();
sender = new Thread(SendMe)
{
Name = "sender",
IsBackground = true
};
sender.Start();
cleanT = new Thread(CleanMap)
{
Name = "cleaner",
IsBackground = true
};
cleanT.Start();
waitForImage = new Thread(WaitForImageRequest)
{
Name = "waitImage",
IsBackground = true
};
waitForImage.Start();
}
private static ObservableConcurrentDictionary <string, string> PerformObservableDictionarySetup(
ICollection <KeyValuePair <string, string> > items)
{
var setupLatch = new CountdownEvent(4 * items.Count);
void SetupCollectionHandler(object sender, NotifyCollectionChangedEventArgs args)
{
setupLatch.Signal();
}
void SetupPropertyHandler(object sender, PropertyChangedEventArgs args)
{
setupLatch.Signal();
}
var observableDictionary =
new ObservableConcurrentDictionary <string, string>(SetupCollectionHandler,
SetupPropertyHandler);
foreach (var item in items)
{
observableDictionary.Add(item);
}
setupLatch.Wait();
observableDictionary.CollectionChanged -= SetupCollectionHandler;
observableDictionary.PropertyChanged -= SetupPropertyHandler;
return(observableDictionary);
}
public ServerSpecificConfig()
{
ListOfSelfAssignableRoles = new ObservableCollection <ulong>();
ObservingStreams = new ObservableCollection <StreamNotificationConfig>();
GenerateCurrencyChannels = new ObservableConcurrentDictionary <ulong, int>();
VoiceChannelLog = new ObservableConcurrentDictionary <ulong, ulong>();
LogserverIgnoreChannels = new ObservableCollection <ulong>();
}
private TreeTaskManager()
{
this._schedulingLock = new object();
this._runningTasksLock = new object();
this._treeControl = null;
this.ProgressManager = null;
this._nodeCounter = null;
this.RunningTasks = new ObservableConcurrentDictionary <long, TreeTask>();
}
private TreeTaskManager()
{
this._schedulingLock = new object();
this._runningTasksLock = new object();
this._treeControl = null;
this.ProgressManager = null;
this._nodeCounter = null;
this.RunningTasks = new ObservableConcurrentDictionary<long, TreeTask>();
}
public bool ReadDatabase()
{
bool success = true;
try
{
if (File.Exists(m_databaseFilename))
{
m_editsDictionary = new ObservableConcurrentDictionary <double, ObservableCollection <FrameEdit> >();
using (BinaryReader br = new BinaryReader(new FileStream(m_databaseFilename, FileMode.Open)))
{
int numFrames = br.ReadInt32(); // read number of frames with edits
// iterate each frame with edits
for (int i = 0; i < numFrames; i++)
{
double timestamp = br.ReadDouble();
int numFrameEdits = br.ReadInt32();
ObservableCollection <FrameEdit> feList = new ObservableCollection <FrameEdit>();
for (int j = 0; j < numFrameEdits; j++)
{
FRAME_EDIT_TYPE type = (FRAME_EDIT_TYPE)br.ReadInt32();
int x1 = br.ReadInt32();
int y1 = br.ReadInt32();
int x2 = br.ReadInt32();
int y2 = br.ReadInt32();
FrameEdit fe = new FrameEdit(type, new BoundingBox(x1, y1, x2, y2));
feList.Add(fe);
}
m_editsDictionary.Add(timestamp, feList);
}
}
}
else
{
success = false;
m_errorMsg = "File does not exist: " + m_databaseFilename;
OnVideoEditsDatabaseEvent(new VideoEditsDatabase_EventArgs(true, m_errorMsg));
}
}
catch (Exception ex)
{
m_errorMsg = ex.Message;
success = false;
OnVideoEditsDatabaseEvent(new VideoEditsDatabase_EventArgs(true, m_errorMsg));
}
return(success);
}
public DataGridViewModel(IComponentContext container, IKeyService service, IEventAggregator eventAggregator, ILoggerFactory loggerfac)
{
this.ea = eventAggregator;
this.container = container;
this.logger = loggerfac.Create <DataGridViewModel>();
var req = new AvailableRequests();
this.Requests = new ObservableCollection <RequestObject>(req.GetRequests());
this.service = service;
this.ApiKeys = new ObservableConcurrentDictionary <string, string>();
this.ConnStrings = new ObservableConcurrentDictionary <string, string>();
this.ApiKeys = service.GetKeys();
this.ConnStrings = service.GetConnections();
this.UpdateServicesCommand = new DelegateCommand(UpdateServices);
this.AddKeyToPluginCommand = new DelegateCommand(AddKeyToPlugin);
this.PingDatabaseCommand = new DelegateCommand(CheckConnection);
this.aTimer = new Timer();
this.SelectedItemKey = Properties.Settings.Default.CurrentKey;
this.SelectedConnString = Properties.Settings.Default.CurrentConnString;
this.Validity = false;
this.dictionary = new ResourceDictionary();
this.dictionary.Source = new Uri("/XModule;component/Resources/ResourceDictionary.xaml", UriKind.RelativeOrAbsolute);
var value = this.dictionary["idatabackup50"].ToString();
this.ImagePath = this.dictionary["idatabackup50"].ToString();
this.ea.GetEvent <ConnectionImageChanged>().Subscribe((oc) =>
{
if (oc)
{
this.ImagePath = this.dictionary["idatabaseview50"].ToString();
}
else
{
this.ImagePath = this.dictionary["ideletedatabase50"].ToString();
}
});
//subsccribes to the add keepa key event
this.ea.GetEvent <AddKeepaKeyEvent>().Subscribe((oc) =>
{
AddKeyToPlugin();
});
//subscribes to the add keepa conn event
this.ea.GetEvent <AddKeepaConnEvent>().Subscribe((oc) =>
{
AddConnToPlugin();
});
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
aTimer.Interval = 500;
aTimer.Enabled = true;
}
public LibraryItem(ISBN isbn, string title, Category category)
{
Validate(new KeyValuePair <string, object>("Title", title));
_isbn = isbn;
_title = title;
_category = category;
_copies = new ObservableConcurrentDictionary <uint, ItemCopy>();
_copies.CollectionChanged += _copies_CollectionChanged;
AddCopy();
}
public Robot()
{
Controllers = new ObservableConcurrentDictionary <uint, Controller>();
Motors = new ObservableCollection <Motor>();
SerialMotors = new ObservableCollection <Motor>();
SerialControllers = new ObservableConcurrentDictionary <uint, Controller>();
setpointTimer = new System.Timers.Timer(19);
setpointTimer.Elapsed += setpointTimer_Elapsed;
//setpointTimer.Start();
//StartUpdates();
}
public Calculation CreateEmptyCalculation()
{
ObservableConcurrentDictionary <string, Parameter> p_in = new ObservableConcurrentDictionary <string, Parameter>();
p_in.Add("x", null);
ObservableConcurrentDictionary <string, Parameter> p_out = new ObservableConcurrentDictionary <string, Parameter>();
p_out.Add("out01", null);
this.calc_candidate = new Calculation(CALC_CANDIDATE_EXPR, CALC_CANDIDATE_NAME, p_in, p_out);
this.calc_record.Add(this.calc_candidate);
return(this.calc_candidate);
}
/// <summary>
/// Creates a named calculation that takes a lambda expression, input and output Parameter instances.
/// </summary>
/// <param name="_name"></param>
/// <param name="_expr">a mathematical expression with named parameters (e.g. (x + y/2)*3.5)</param>
/// <param name="_parameters_in">List of input parameters</param>
/// <param name="_parameters_out">List of output parameters (each receives the same value)</param>
/// <returns></returns>
internal Calculation CreateCalculation(string _name, string _expr, Dictionary <string, Parameter> _parameters_in,
Dictionary <string, Parameter> _parameters_out)
{
if (string.IsNullOrEmpty(_name) || string.IsNullOrEmpty(_expr) ||
_parameters_in == null || _parameters_in.Count < 1 ||
_parameters_out == null || _parameters_out.Count < 1)
{
return(null);
}
ObservableConcurrentDictionary <string, Parameter> p_IN = new ObservableConcurrentDictionary <string, Parameter>();
foreach (var entry in _parameters_in)
{
p_IN.Add(entry.Key, entry.Value);
}
ObservableConcurrentDictionary <string, Parameter> p_OUT = new ObservableConcurrentDictionary <string, Parameter>();
foreach (var entry in _parameters_out)
{
p_OUT.Add(entry.Key, entry.Value);
}
try
{
Dictionary <string, double> params_in_value = new Dictionary <string, double>();
foreach (var entry in p_IN)
{
if (entry.Value == null)
{
continue;
}
params_in_value.Add(entry.Key, entry.Value.ValueCurrent);
}
// try to parse the expression(SPACES and UNDERLINES cause Exceptions!!!)
Func <double> func = CalculationFactory.CALCULATOR.ParseExpression(_expr, params_in_value).Compile();
if (func == null)
{
return(null);
}
// create the Calculation instance ONLY if parsing was successful
Calculation c = new Calculation(_expr, _name, p_IN, p_OUT);
this.calc_record.Add(c);
return(c);
}
catch (Exception e)
{
string debug = e.Message;
MessageBox.Show(debug, "Eingabefehler Gleichung", MessageBoxButton.OK, MessageBoxImage.Error);
return(null);
}
}
public SeasonalItemsViewModel()
{
Title = "What's in Season?";
Items = new ObservableConcurrentDictionary <int, SeasonalItem>();
DocsChangeIndexes = new HashSet <int>();
LoadItemsCommand = new Command(() => ExecuteLoadItemsCommand());
SaveDocumentsCommand = new Command(async() => await ExecuteSaveDocumentsCommand());
//tag::LoadData[]
var q = QueryBuilder.Select(SelectResult.All())
.From(DataSource.Database(_db))
.Where(Meta.ID.EqualTo(Expression.String(CoreApp.DocId)))
.AddChangeListener((sender, args) =>
{
var allResult = args.Results.AllResults();
var result = allResult[0];
var dict = result[CoreApp.DB.Name].Dictionary;
var arr = dict.GetArray(CoreApp.ArrKey);
if (arr.Count < Items.Count)
{
Items = new ObservableConcurrentDictionary <int, SeasonalItem>();
}
Parallel.For(0, arr.Count, i =>
{
var item = arr[i].Dictionary;
var name = item.GetString("key");
var cnt = item.GetInt("value");
var image = item.GetBlob("image");
if (_items.ContainsKey(i))
{
_items[i].Name = name;
_items[i].Quantity = cnt;
_items[i].ImageByteArray = image?.Content;
}
else
{
var seasonalItem = new SeasonalItem {
Index = i,
Name = name,
Quantity = cnt,
ImageByteArray = image?.Content
};
_items.Add(i, seasonalItem);
}
});
});
//end::LoadData[]
}
private void InitializeHelix()
{
_items.Clear();
_controllerObjects = new ObservableConcurrentDictionary <MotionControllerModel, SphereVisual3D>();
_items.Add(new SunLight());
_items.Add(new GridLinesVisual3D
{
Width = 500,
Length = 500
});
CubeVisual3D camera = new CubeVisual3D
{
SideLength = 10,
Fill = new SolidColorBrush(Colors.Blue),
Center = new Point3D(_camera.Calibration.TranslationToWorld[0, 0],
_camera.Calibration.TranslationToWorld[2, 0],
_camera.Calibration.TranslationToWorld[1, 0])
};
_items.Add(camera);
ArrowVisual3D axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(100, 0, 0),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Red)
};
_items.Add(axis);
axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(0, 100, 0),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Green)
};
_items.Add(axis);
axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(0, 0, 100),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Blue)
};
_items.Add(axis);
}
public void SetDataRange(Enum key, uint value, ObservableConcurrentDictionary <Enum, DataBlock> dataMap)
{
byte[] bytes = BitConverter.GetBytes(value);
Array.Reverse(bytes);
using (var dataEntryEnumarator = dataMap[key].GetDataEntries())
{
int i = 0;
while (dataEntryEnumarator.MoveNext() && i < bytes.Length)
{
dataMap[key].UpdateData(dataEntryEnumarator.Current.Key, bytes[i++]);
}
}
}
public void TestTryAdd()
{
var latch = new CountdownEvent(4);
var collectionChangedActions = new List <NotifyCollectionChangedAction>();
var propertiesChanged = new List <string>();
void CollectionChangedHandler(object sender, NotifyCollectionChangedEventArgs args)
{
collectionChangedActions.Add(args.Action);
latch?.Signal();
}
void PropertyChangedHandler(object sender, PropertyChangedEventArgs args)
{
propertiesChanged.Add(args.PropertyName);
latch?.Signal();
}
var observableDictionary =
new ObservableConcurrentDictionary <string, string>(CollectionChangedHandler, PropertyChangedHandler);
var success = observableDictionary.TryAdd("1", "value");
latch.Wait();
Assert.True(success);
Assert.Single(observableDictionary);
var keys = new string[1];
observableDictionary.Keys.CopyTo(keys, 0);
Assert.Equal("1", keys[0]);
var values = new string[1];
observableDictionary.Values.CopyTo(values, 0);
Assert.Equal("value", values[0]);
Assert.Single(collectionChangedActions);
Assert.Equal(NotifyCollectionChangedAction.Add, collectionChangedActions[0]);
Assert.Equal(3, propertiesChanged.Count);
Assert.Contains("Count", propertiesChanged);
Assert.Contains("Keys", propertiesChanged);
Assert.Contains("Values", propertiesChanged);
latch.Dispose();
}
public ObservableConcurrentDictionaryView(ObservableConcurrentDictionary <TKey, TValue> dictionary, Func <TValue, TView> selector, string propertyName)
{
_propertyName = propertyName;
_selector = selector;
_view = new ObservableConcurrentDictionary <TKey, TView>();
_view.PropertyChanged += (s, e) => PropertyChanged?.Invoke(s, e);
_view.CollectionChanged += (s, e) => CollectionChanged?.Invoke(s, e);
_dictionary = dictionary;
_dictionary.CollectionChanged += OnSourceCollectionChanged;
_dictionary.PropertyChanged += OnSourceItemPropertyChanged;
OnSourceCollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, _dictionary.ToList()));
}
/// <summary>
/// Is to be called only by the CalculationFactory, Component, and DXFComponent.
/// </summary>
/// <param name="_expr">a mathematical expression with named parameters (e.g. (x + y/2)*3.5)</param>
/// <param name="_parameters_in">List of input parameters</param>
/// <param name="_parameters_out">List of output / return parameters (each receives the same value)</param>
internal Calculation(string _expr, string _name, ObservableConcurrentDictionary <string, Parameter> _parameters_in,
ObservableConcurrentDictionary <string, Parameter> _parameters_out)
{
this.ID = (++Calculation.NR_CALCULATIONS);
this.Name = _name;
this.Expression = _expr;
this.InputParams = _parameters_in;
this.ReturnParams = _parameters_out;
this.GatherInputParamNames();
this.GatherReturnParamNames();
this.IsExpanded = false;
this.IsSelected = false;
this.OwnerIsSelected = false;
this.UpToDate = true;
}
public TransmissionLossCalculatorService()
{
WorkQueue = new ObservableConcurrentDictionary<Guid, Radial>();
var calculator = new ActionBlock<Radial>(radial =>
{
if (!radial.IsDeleted) Calculate(radial);
WorkQueue.Remove(radial.Guid);
_shadeFileProcessorQueue.Post(radial);
}, new ExecutionDataflowBlockOptions { BoundedCapacity = -1, MaxDegreeOfParallelism = System.Environment.ProcessorCount });
_calculatorQueue = new BufferBlock<Radial>(new DataflowBlockOptions { BoundedCapacity = -1 });
_calculatorQueue.LinkTo(calculator);
var shadeFileProcessor = new ActionBlock<Radial>(r =>
{
if (!r.IsDeleted && r.ExtractAxisData()) r.ReleaseAxisData();
}, new ExecutionDataflowBlockOptions { BoundedCapacity = -1, MaxDegreeOfParallelism = System.Environment.ProcessorCount });
_shadeFileProcessorQueue = new BufferBlock<Radial>(new DataflowBlockOptions { BoundedCapacity = -1 });
_shadeFileProcessorQueue.LinkTo(shadeFileProcessor);
}
protected AbstractOutputTarget(int instanceIndex, IEventAggregator eventAggregator, IDeviceAxisValueProvider valueProvider)
{
InstanceIndex = instanceIndex;
EventAggregator = eventAggregator;
_valueProvider = valueProvider;
_statusEvent = new AsyncManualResetEvent();
Values = DeviceAxis.All.ToDictionary(a => a, a => a.DefaultValue);
AxisSettings = new ObservableConcurrentDictionary <DeviceAxis, DeviceAxisSettings>(DeviceAxis.All.ToDictionary(a => a, _ => new DeviceAxisSettings()));
UpdateInterval = 10;
PropertyChanged += (s, e) =>
{
if (string.Equals(e.PropertyName, "Status", StringComparison.OrdinalIgnoreCase))
{
_statusEvent.Reset();
}
};
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values[0] == null || values[1] == null)
{
return(false);
}
if (values[0] == DependencyProperty.UnsetValue)
{
return(false);
}
if (values[1] == DependencyProperty.UnsetValue)
{
return(false);
}
ObservableConcurrentDictionary <CameraModel, bool> dict = (ObservableConcurrentDictionary <CameraModel, bool>)values[0];
CameraModel camera = (CameraModel)values[1];
bool tracking = dict[camera];
return(tracking);
}
private void SetSelectedItems()
{
if (SelectedItems == null)
{
SelectedItems = new ObservableConcurrentDictionary <string, object>();
}
//else
// ((ICollection<KeyValuePair<string, object>>)SelectedItems).Clear();
foreach (var node in _nodeList.Where(node => node.Title != "All"))
{
if (node.IsSelected)
{
SelectedItems.Add(node.Title, ItemsSource[node.Title]);
}
else
{
SelectedItems.Remove(node.Title);
}
}
SelectionChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Make all new objects, restarts our stopwatch, starts search
/// </summary>
private void ExecuteSearch()
{
_numResults = 0;
RefreshListView();
progressBar.Maximum = _paraCount = DocumentHelpers.ActiveDocument.Paragraphs.Count;
_cts = new CancellationTokenSource();
_observableResults = new ObservableConcurrentDictionary <Word.Range, string>();
_resultMap = new Dictionary <int, Word.Range>();
_hashList = new HashSet <string>();
_observableResults.CollectionChanged += AddedNewResult;
_progressIndicator = new Progress <int>(UpdateStatuses);
SetProxObject();
if (DocumentHasChanges && (_prox != null))
{
GetParagraphMarkers();
}
_stopwatch = new Stopwatch();
_stopwatch.Start();
UpdateStatuses(0);
GetObservableResults();
}
public void TestAddOrUpdate_TryRemove()
{
var npc = new NotifyPropertyChangedImpl();
const string testKey = "One";
var ocd = new ObservableConcurrentDictionary <string, NotifyPropertyChangedImpl>();
ocd.AddOrUpdate(testKey, npc, (s, impl) => throw new InvalidOperationException());
// Register without doing, just to make sure we also test the event generation for now
ocd.CollectionChanged += (sender, args) =>
{
Log.Info().WriteLine($"Old location: {args.OldStartingIndex}");
};
var isNpcTriggered = false;
// Subscribe to the PropertyChanged
using (ocd.OnPropertyChanged().Subscribe(args => isNpcTriggered = true))
{
// change a value, a NPC is triggered
npc.Name = "Robin1";
// Test trigger
Assert.True(isNpcTriggered);
// Reset the trigger test value
isNpcTriggered = false;
// Remove the item, this should remove the event registration
Assert.True(ocd.TryRemove(testKey, out _));
// change a value, a NPC is triggered
npc.Name = "Robin2";
// Make sure we DID NOT get the trigger
Assert.False(isNpcTriggered);
}
}
public void Expose(ActorExposureRecord exposureRecord)
{
if (Filter1 == null) throw new ApplicationException("Filter1 cannot be null");
if (Filter2 == null) throw new ApplicationException("Filter2 cannot be null");
var key1 = Filter1(exposureRecord);
if (!key1.HasValue) return;
var key2 = Filter2(exposureRecord);
if (!key2.HasValue) return;
ObservableConcurrentDictionary<int, ObservableCollection<HistogramBins>> level2;
if (!Exposures.TryGetValue(key1.Value, out level2))
{
level2 = new ObservableConcurrentDictionary<int, ObservableCollection<HistogramBins>>();
if (!Exposures.TryAdd(key1.Value, level2)) if (!Exposures.TryGetValue(key1.Value, out level2)) throw new ApplicationException("Could not add level two dictionary.");
}
ObservableCollection<HistogramBins> bins;
if (!level2.TryGetValue(key2.Value, out bins))
{
bins = new ObservableCollection<HistogramBins> { new HistogramBins(_histogramSource), new HistogramBins(_histogramSource) }; //peakSPL and Energy
if (!level2.TryAdd(key2.Value, bins)) if (!level2.TryGetValue(key2.Value, out bins)) throw new ApplicationException("Could not add bins.");
}
bins[0].Add(exposureRecord.PeakSPL);
bins[1].Add(exposureRecord.Energy);
}
public VideoEditsDatabase(string mp4Filename)
{
if (File.Exists(mp4Filename))
{
m_mp4Filename = mp4Filename;
m_databaseFilename = BuildVideoEditsDatabaseFilename(m_mp4Filename);
m_editsDictionary = new ObservableConcurrentDictionary <double, ObservableCollection <FrameEdit> >();
if (File.Exists(m_databaseFilename))
{
if (ReadDatabase())
{
OnVideoEditsDatabaseEvent(new VideoEditsDatabase_EventArgs(false, "Reading Existing Edit Database:\n" +
m_databaseFilename));
}
}
}
else
{
OnVideoEditsDatabaseEvent(new VideoEditsDatabase_EventArgs(true, "File does not exist:\n" + mp4Filename));
}
}
/// <summary>Set all values</summary>
public static void setStandardValues(ref dynamic vaProxy)
{
// Update our primary objects only if they don't match the state of the EDDI instance.
try
{
if (EDDI.Instance.CurrentStarSystem != CurrentStarSystem)
{
setStarSystemValues(EDDI.Instance.CurrentStarSystem, "System", ref vaProxy);
CurrentStarSystem = EDDI.Instance.CurrentStarSystem;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set current system", ex);
}
try
{
if (EDDI.Instance.LastStarSystem != LastStarSystem)
{
setStarSystemValues(EDDI.Instance.LastStarSystem, "Last system", ref vaProxy);
LastStarSystem = EDDI.Instance.LastStarSystem;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set last system", ex);
}
try
{
if (EDDI.Instance.CurrentStellarBody != CurrentStellarBody)
{
setDetailedBodyValues(EDDI.Instance.CurrentStellarBody, "Body", ref vaProxy);
CurrentStellarBody = EDDI.Instance.CurrentStellarBody;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set stellar body", ex);
}
try
{
if (EDDI.Instance.CurrentStation != CurrentStation)
{
setStationValues(EDDI.Instance.CurrentStation, "Last station", ref vaProxy);
CurrentStation = EDDI.Instance.CurrentStation;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set last station", ex);
}
try
{
ShipMonitor shipMonitor = ((ShipMonitor)EDDI.Instance.ObtainMonitor("Ship monitor"));
try
{
if (shipMonitor?.GetCurrentShip() != Ship)
{
setShipValues(shipMonitor?.GetCurrentShip(), "Ship", ref vaProxy);
Ship = shipMonitor.GetCurrentShip();
}
}
catch (Exception ex)
{
Logging.Error("Failed to set current ship values", ex);
}
try
{
if (shipMonitor?.shipyard != Shipyard)
{
List <Ship> shipyard = new List <Ship>(shipMonitor?.shipyard);
if (shipyard != null)
{
int currentStoredShip = 1;
foreach (Ship StoredShip in shipyard)
{
setShipValues(StoredShip, "Stored ship " + currentStoredShip, ref vaProxy);
currentStoredShip++;
}
vaProxy.SetInt("Stored ship entries", shipMonitor?.shipyard.Count);
}
Shipyard = shipMonitor.shipyard;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set shipyard", ex);
}
}
catch (Exception ex)
{
Logging.Error("Failed to obtain ship monitor & set VoiceAttack values", ex);
}
try
{
if (EDDI.Instance.HomeStarSystem != HomeStarSystem)
{
setStarSystemValues(EDDI.Instance.HomeStarSystem, "Home system", ref vaProxy);
HomeStarSystem = EDDI.Instance.HomeStarSystem;
// Backwards-compatibility with 1.x
try
{
if (EDDI.Instance.HomeStarSystem != null)
{
vaProxy.SetText("Home system", EDDI.Instance.HomeStarSystem.name);
vaProxy.SetText("Home system (spoken)", Translations.StarSystem(EDDI.Instance.HomeStarSystem.name));
}
if (EDDI.Instance.HomeStation != null)
{
vaProxy.SetText("Home station", EDDI.Instance.HomeStation.name);
}
}
catch (Exception ex)
{
Logging.Error("Failed to set 1.x home system values", ex);
}
}
}
catch (Exception ex)
{
Logging.Error("Failed to set home system", ex);
}
try
{
Status currentStatus = ((StatusMonitor)EDDI.Instance.ObtainMonitor("Status monitor"))?.GetStatus();
if (currentStatus != Status)
{
setStatusValues(StatusMonitor.currentStatus, "Status", ref vaProxy);
Status = currentStatus;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set current status", ex);
}
try
{
// Set SetState values
if (EDDI.Instance.State != State)
{
setDictionaryValues(EDDI.Instance.State, "state", ref vaProxy);
State = EDDI.Instance.State;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set state", ex);
}
try
{
if (EDDI.Instance.Cmdr != Commander)
{
setCommanderValues(EDDI.Instance.Cmdr, ref vaProxy);
Commander = EDDI.Instance.Cmdr;
}
}
catch (Exception ex)
{
Logging.Error("Failed to set commander values", ex);
}
// On every event...
// Set miscellaneous values
try
{
vaProxy.SetText("Environment", EDDI.Instance.Environment);
vaProxy.SetText("Vehicle", EDDI.Instance.Vehicle);
vaProxy.SetText("EDDI version", Constants.EDDI_VERSION.ToString());
}
catch (Exception ex)
{
Logging.Error("Failed to set misc values", ex);
}
}
public void PurgeThumbCache()
{
cache = new ObservableConcurrentDictionary<string, BitmapImage>();
}
public IODevice()
{
DataMapIn = new ObservableConcurrentDictionary <Enum, DataBlock>();
DataMapOut = new ObservableConcurrentDictionary <Enum, DataBlock>();
}
/* private List<XMLSimSetupNotification> _simulations = new List<XMLSimSetupNotification>();
public List<XMLSimSetupNotification> Simulations
{
get
{
return _simulations;
}
set
{
_simulations = value;
}
}*/
public MainWindow()
{
InitializeComponent();
//necessary for data binding
this.DataContext = this;
_setupMessages = new ObservableConcurrentDictionary<string, XMLSimSetupNotification>();
_participantList = new ObservableConcurrentDictionary<string, SimulationParticipant>();
LoadApplicationData(); // <---------start
}
private void OnDeserializing(StreamingContext context)
{
_copies = new ObservableConcurrentDictionary <uint, ItemCopy>();
}
private void InitializeHelix()
{
_items.Clear();
_controllerObjects = new ObservableConcurrentDictionary<MotionControllerModel, SphereVisual3D>();
_items.Add(new SunLight());
_items.Add(new GridLinesVisual3D
{
Width = 500,
Length = 500
});
CubeVisual3D camera = new CubeVisual3D
{
SideLength = 10,
Fill = new SolidColorBrush(Colors.Blue),
Center = new Point3D(_camera.Calibration.TranslationToWorld[0, 0],
_camera.Calibration.TranslationToWorld[2, 0],
_camera.Calibration.TranslationToWorld[1, 0])
};
_items.Add(camera);
ArrowVisual3D axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(100, 0, 0),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Red)
};
_items.Add(axis);
axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(0, 100, 0),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Green)
};
_items.Add(axis);
axis = new ArrowVisual3D
{
Origin = new Point3D(0, 0, 0),
Direction = new Vector3D(0, 0, 100),
Diameter = 2,
Fill = new SolidColorBrush(Colors.Blue)
};
_items.Add(axis);
}
public HelixCameraVisualizationService()
{
_controllerObjects = new ObservableConcurrentDictionary<MotionControllerModel, SphereVisual3D>();
}
public BinnedExposureDictionary(IHistogramSource histogramSource)
{
Exposures = new ObservableConcurrentDictionary<int, ObservableConcurrentDictionary<int, ObservableCollection<HistogramBins>>>();
_histogramSource = histogramSource;
}
public Settings()
{
accountsDict = new ObservableConcurrentDictionary<string, UserCredential>();
}
public static Task FindText(string searchKey,
bool searchKeyCaseSensitive,
ObservableConcurrentDictionary <Word.Range, string> observableResults,
IProgress <int> progress,
CancellationToken cancelToken,
ProxSearchSettings prox = null)
{
return(Task.Run(() =>
{
var paraVisitedCount = 0;
var proxIsNull = (prox == null);
int totalParaCount = DocumentHelpers.ActiveDocument.Paragraphs.Count;
var pOpts = new ParallelOptions {
CancellationToken = cancelToken
};
var sKeyRegOpts = searchKeyCaseSensitive ? SysRegex.RegexOptions.None : SysRegex.RegexOptions.IgnoreCase;
var searchKeyRegex = proxIsNull
? new SysRegex.Regex(searchKey, sKeyRegOpts)
: new SysRegex.Regex(searchKey + ".*?" + prox.SearchKey + "|" + prox.SearchKey + ".*?" + searchKey + "|" + searchKey, sKeyRegOpts);
Parallel.ForEach(DocumentHelpers.GetParagraphsEnumerator(),
pOpts,
(currentParagraph, loopState, index) =>
{
// Catch this cancellation throw in the FindPane to update the pane/results
pOpts.CancellationToken.ThrowIfCancellationRequested();
var paraRange = ((Word.Paragraph)currentParagraph).Range;
// Find all of the single Find matches
if (proxIsNull)
{
FinderHelpers.DoFind(searchKeyRegex.Match(paraRange.Text),
paraRange.Start,
paraRange.End,
observableResults);
}
#region Proximity Matching
// Proximity matching
else
{
// If we are doing interparagraph matching, let's make sure we don't
// try to access a paragraph out of bounds
if (prox.ParaProximity)
{
int lookaheadPosition = (int)index + prox.ParaThreshold;
int topRange = (lookaheadPosition > totalParaCount)
? totalParaCount
: lookaheadPosition;
//Debug.WriteLine("LAP: " + lookaheadPosition.ToString() +
// "Total: " + totalParaCount.ToString() +
// "topRng: " + topRange.ToString());
paraRange.End = prox.ParaEndingRanges[topRange - 1];
}
IEnumerable <SysRegex.Match> matches = null;
if (paraRange.Text != null)
{
if (!prox.LogicalNot)
{
searchKeyRegex = new SysRegex.Regex(searchKey + ".*?" + prox.SearchKey, sKeyRegOpts);
var proxKeyRegex = new SysRegex.Regex(prox.SearchKey + ".*?" + searchKey, sKeyRegOpts);
var skMatches = searchKeyRegex.Matches(paraRange.Text);
var pkMatches = proxKeyRegex.Matches(paraRange.Text);
matches = skMatches.OfType <SysRegex.Match>()
.Concat(pkMatches.OfType <SysRegex.Match>())
.Where(m => m.Success);
}
else
{
// why didn't we do this in the assignment of matches and let the if statement
// override its value? imagine all of the wasted ops this call does
// if its not needed!
matches = searchKeyRegex.Matches(paraRange.Text).OfType <SysRegex.Match>();
}
FinderHelpers.DoFindProximity(matches,
paraRange.Start,
paraRange.End,
new SysRegex.Regex(searchKey, sKeyRegOpts),
prox,
observableResults);
}
}
#endregion Proximity Matching
// Report back our progress
progress.Report(++paraVisitedCount);
});
}, cancelToken));
}
public Robot()
{
Controllers = new ObservableConcurrentDictionary <uint, Controller>();
Motors = new ObservableCollection <Motor>();
timer.Elapsed += timer_Elapsed;
}
public Configuration()
{
//First Time Installs
redist_first_time = true;
logitech_first_time = true;
corsair_first_time = true;
razer_first_time = true;
steelseries_first_time = true;
dualshock_first_time = true;
//General Program Settings
allow_peripheral_devices = true;
UseVolumeAsBrightness = false;
allow_wrappers_in_background = true;
allow_all_logitech_bitmaps = true;
GlobalBrightness = 1.0f;
KeyboardBrightness = 1.0f;
PeripheralBrightness = 1.0f;
updates_check_on_start_up = true;
start_silently = false;
close_mode = AppExitMode.Ask;
mouse_orientation = MouseOrientationType.RightHanded;
keyboard_brand = PreferredKeyboard.None;
keyboard_localization = PreferredKeyboardLocalization.None;
mouse_preference = PreferredMouse.None;
virtualkeyboard_keycap_type = KeycapType.Default;
detection_mode = ApplicationDetectionMode.WindowsEvents;
excluded_programs = new HashSet <string>();
//additional_profiles = new Dictionary<string, GenericApplicationProfileManager>();
devices_disable_keyboard = false;
devices_disable_mouse = false;
devices_disable_headset = false;
devices_disabled = new HashSet <Type>();
devices_disabled.Add(typeof(Devices.Dualshock.DualshockDevice));
devices_disabled.Add(typeof(Devices.AtmoOrbDevice.AtmoOrbDevice));
devices_disabled.Add(typeof(Devices.NZXT.NZXTDevice));
OverlaysInPreview = true;
//Blackout and Night theme
time_based_dimming_enabled = false;
time_based_dimming_affect_games = false;
time_based_dimming_start_hour = 21;
time_based_dimming_start_minute = 0;
time_based_dimming_end_hour = 8;
time_based_dimming_end_minute = 0;
nighttime_enabled = false;
nighttime_start_hour = 20;
nighttime_start_minute = 0;
nighttime_end_hour = 7;
nighttime_end_minute = 0;
//// Idle Effects
idle_type = IdleEffects.None;
idle_delay = 5;
idle_speed = 1.0f;
idle_effect_primary_color = Color.FromArgb(0, 255, 0);
idle_effect_secondary_color = Color.FromArgb(0, 0, 0);
idle_amount = 5;
idle_frequency = 2.5f;
//Debug
BitmapDebugTopMost = false;
HttpDebugTopMost = false;
//ProfileOrder = new List<string>(ApplicationProfiles.Keys);
VarRegistry = new VariableRegistry();
EvaluatableTemplates = new ObservableConcurrentDictionary <string, IEvaluatable>();
}
public HelixCameraVisualizationService()
{
_controllerObjects = new ObservableConcurrentDictionary <MotionControllerModel, SphereVisual3D>();
}
public ServerModel()
{
_childSockets = new ObservableConcurrentDictionary<SimpleServerChildTcpSocket, ChildSocketState>();
_clients = new ObservableConcurrentDictionary<SimpleServerChildTcpSocket, ClientModel>();
_port = 3000;
}
