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 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 void AddFrameEdit(double timestamp, FRAME_EDIT_TYPE type, BoundingBox bbox)
{
if (bbox.x2 - bbox.x1 > m_minimumRedactionSize && bbox.y2 - bbox.y1 > m_minimumRedactionSize) // make sure bounding box is big enough
{
if (m_editsDictionary.ContainsKey(timestamp))
{
ObservableCollection <FrameEdit> list = m_editsDictionary[timestamp];
list.Add(new FrameEdit(type, bbox));
}
else
{
ObservableCollection <FrameEdit> list = new ObservableCollection <FrameEdit>();
list.Add(new FrameEdit(type, bbox));
m_editsDictionary.Add(timestamp, list);
}
}
}
public ItemCopy AddCopy()
{
var itemCopy = new ItemCopy {
CopyNo = _copies.Keys.LastOrDefault() + 1
};
_copies.Add(itemCopy.CopyNo, itemCopy);
return(itemCopy);
}
private void ClientOnDeviceAdded(object sender, DeviceAddedEventArgs e)
{
if (Devices.TryGetValue(e.Device.Index, out var dev))
{
if (!dev.Name.Equals(e.Device.Name, StringComparison.Ordinal))
{
Devices.Remove(e.Device.Index);
Devices.Add(e.Device.Index, new ButtplugPanelDevice(e.Device));
return;
}
dev.Device = e.Device;
dev.IsConnected = true;
}
else
{
Devices.Add(e.Device.Index, new ButtplugPanelDevice(e.Device));
}
}
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 void RegisterPlugin(string key, IExceptionlessPlugin plugin)
{
if (_plugins.ContainsKey(key))
{
_plugins[key] = plugin;
}
else
{
_plugins.Add(key, plugin);
}
}
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 void TestAddWithKeyValuePair()
{
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 item = new KeyValuePair <string, string>("1", "value");
observableDictionary.Add(item);
latch.Wait();
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();
}
private async void StartUpdateTask()
{
if (_updateTask != null && _updateTask.Status == TaskStatus.Running)
{
return;
}
_ctsUpdate = new CancellationTokenSource();
try
{
_updateTask = Task.Factory.StartNew(() =>
{
Stopwatch sw = new Stopwatch();
while (!_ctsUpdate.Token.IsCancellationRequested)
{
sw.Restart();
foreach (MotionControllerModel mc in _camera.Controllers)
{
var mc1 = mc;
// update if the controller is selected for tracking
if (mc.Tracking.ContainsKey(_camera) && mc.Tracking[_camera])
{
// add if missing
if (!_controllerObjects.ContainsKey(mc))
{
DispatcherHelper.UIDispatcher.Invoke(() =>
{
// convert color
byte r = (byte)(mc1.Color.r * 255 + 0.5);
byte g = (byte)(mc1.Color.g * 255 + 0.5);
byte b = (byte)(mc1.Color.b * 255 + 0.5);
Color color = Color.FromRgb(r, g, b);
SphereVisual3D sphere = new SphereVisual3D
{
Center = new Point3D(mc1.WorldPosition[_camera].x,
mc1.WorldPosition[_camera].z,
mc1.WorldPosition[_camera].y),
Radius = ((int)((14.0 / Math.PI) * 100)) / 200.0,
Fill = new SolidColorBrush(color)
};
_controllerObjects.Add(mc1, sphere);
_items.Add(sphere);
});
}
// update position
if (mc.WorldPosition.ContainsKey(_camera))
{
DispatcherHelper.UIDispatcher.Invoke((Action)(() => _controllerObjects[mc1].Center = new Point3D(
mc1.WorldPosition[_camera].x,
mc1.WorldPosition[_camera].z,
mc1.WorldPosition[_camera].y)));
}
}
// remove objects corresponding to unselected controllers
else
{
if (_controllerObjects.ContainsKey(mc))
{
DispatcherHelper.UIDispatcher.Invoke((Action)(() => _items.Remove(_controllerObjects[mc1])));
_controllerObjects.Remove(mc);
}
}
} // foreach
sw.Stop();
// taking the processing time of the task itself into account, pause the thread to approximately reach the given FPS
Thread.Sleep((int)(Math.Max((1000.0 / _camera.FPS) - sw.ElapsedMilliseconds, 0) + 0.5));
} // while
}, _ctsUpdate.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
await _updateTask;
}
catch (OperationCanceledException ex)
{
Console.WriteLine(ex.StackTrace);
Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
Stop();
}
}
