public void Init(int rows, int cols, int margin, int padding, int maxNumPoints, List <MultiChartArray_TraceItem> traces)
{
int numTraces = traces.Count;
m_vm = new MultiChartArray_ViewModel(rows, cols, padding, margin, maxNumPoints, traces);
DataContext = m_vm;
////////////////////////////////////////////////////////////////////////////////////////
m_mouseDownRow = -1;
m_mouseDownCol = -1;
m_numPoints = 0;
InitializeComponent();
m_visibleSignal = SIGNAL_TYPE.RAW;
m_buttonColorNotSelected = Colors.LightGray;
m_buttonColorSelected = Colors.Red;
m_rowButton = new List <Button>();
m_columnButton = new List <Button>();
BuildChartArray();
SetupVisiblityCheckBoxes(m_vm.traces);
m_refreshTimer = new DispatcherTimer();
m_refreshTimer.Tick += M_refreshTimer_Tick;
m_refreshTimer.Interval = TimeSpan.FromMilliseconds(100);
m_refreshTimer.Start();
m_newDataAdded = false;
m_dataPipeline = CreateDataPipeline(m_tokenSource.Token, m_chartArrays);
m_guiPipeline = CreateGuiPipeline(m_uiTask, m_tokenSource.Token, m_chartArrays, m_vm);
}
public ITargetBlock <Tuple <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE> > CreateGuiPipeline(TaskScheduler uiTask,
CancellationToken cancelToken,
Dictionary <SIGNAL_TYPE, ChartArray> _charts,
MultiChartArray_ViewModel _vm)
{
Dictionary <SIGNAL_TYPE, ChartArray> charts = _charts;
MultiChartArray_ViewModel vm = _vm;
SIGNAL_TYPE visibleSignal = SIGNAL_TYPE.RAW;
int[] axisRange = new int[4];
var GuiUpdates = new ActionBlock <Tuple <int[], int[], SIGNAL_TYPE, int, COMMAND_TYPE> >(inputData =>
{
// INPUTS:
// item 1 - x data array
// item 2 - y data array
// item 3 - the data's signal type, i.e. RAW, STATIC_RATIO, CONTROL_SUBTRACTION, or DYNAMIC_RATIO
// item 4 - the index of the indicator to which this data belongs
// item 5 - command type that is put on the queue. Depending on what this is, the previous parameters are
// interpreted differently. For example, if it is RESIZE, the new bitmap dimensions should be
// in x and y (items 1 and 2 above). The new chartArray should be x[0], y[0],
// and the new aggregate chart should be x[1], y[1].
if (inputData == null)
{
return;
}
int[] x = inputData.Item1;
int[] y = inputData.Item2;
SIGNAL_TYPE signalType = inputData.Item3;
int indicatorNdx = inputData.Item4;
COMMAND_TYPE commandType = inputData.Item5;
try
{
switch (commandType)
{
case COMMAND_TYPE.RESIZE:
// resize chartArray and aggregate bitmaps
// find the optimal size to best fit the Actual window size
int pixelWidthPerChart = (x[0] - (2 * vm.margin) - ((vm.cols - 1) * vm.padding)) / vm.cols;
int pixelHeightPerChart = (y[0] - (2 * vm.margin) - ((vm.rows - 1) * vm.padding)) / vm.rows;
int w = (pixelWidthPerChart * vm.cols) + ((vm.cols - 1) * vm.padding) + (2 * vm.margin);
int h = (pixelHeightPerChart * vm.rows) + ((vm.rows - 1) * vm.padding) + (2 * vm.margin);
if (w != vm.chartArrayWidth || h != vm.chartArrayHeight)
{
vm.chartArrayWidth = w;
vm.chartArrayHeight = h;
vm.aggregateWidth = x[1];
vm.aggregateHeight = y[1];
vm.bitmap = BitmapFactory.New(w, h);
vm.overlay = BitmapFactory.New(w, h);
vm.aggregateBitmap = BitmapFactory.New(x[1], y[1]);
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
charts[signal].Resize(w, h, x[1], y[1]);
}
}
// refresh chart array
charts[visibleSignal].Redraw();
WriteableBitmap bitmapRef4 = vm.bitmap;
charts[visibleSignal].Refresh(ref bitmapRef4);
// refresh aggregate chart
charts[visibleSignal].RedrawAggregate();
WriteableBitmap aggregateBitmapRef4 = vm.aggregateBitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef4);
break;
case COMMAND_TYPE.REFRESH:
visibleSignal = signalType;
// refresh chart array image
charts[visibleSignal].Redraw();
WriteableBitmap bitmapRef1 = vm.bitmap;
charts[visibleSignal].Refresh(ref bitmapRef1);
// refresh aggregate image
charts[visibleSignal].RedrawAggregate();
WriteableBitmap aggregateBitmapRef1 = vm.aggregateBitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef1);
// update the range labels
charts[visibleSignal].GetRanges(ref axisRange);
vm.xMaxText = axisRange[1].ToString();
vm.yMinText = axisRange[2].ToString();
vm.yMaxText = axisRange[3].ToString();
break;
case COMMAND_TYPE.RESET:
// clears data from all charts
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
charts[signal].Reset();
charts[signal].Redraw();
charts[signal].RedrawAggregate();
}
WriteableBitmap bitmapRef2 = vm.bitmap;
charts[visibleSignal].Refresh(ref bitmapRef2);
WriteableBitmap aggregateBitmapRef2 = vm.aggregateBitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef2);
// update the range labels
charts[visibleSignal].GetRanges(ref axisRange);
vm.xMaxText = axisRange[1].ToString();
vm.yMinText = axisRange[2].ToString();
vm.yMaxText = axisRange[3].ToString();
m_totalPoints = 0;
break;
case COMMAND_TYPE.SET_SELECTED:
// have to convert to a 1D bool array, because that's what is needed by the C++ function
bool[] temp = new bool[vm.rows * vm.cols];
for (int r = 0; r < vm.rows; r++)
{
for (int c = 0; c < vm.cols; c++)
{
temp[r * vm.cols + c] = m_chartSelected[r, c];
}
}
foreach (int value in Enum.GetValues(typeof(SIGNAL_TYPE)))
{
SIGNAL_TYPE signal = (SIGNAL_TYPE)value;
// refresh chart array
charts[signal].Redraw();
if (signal == visibleSignal)
{
WriteableBitmap bitmapRef3 = vm.bitmap;
charts[signal].SetSelectedCharts(temp, ref bitmapRef3);
}
else
{
charts[signal].SetSelectedCharts(temp);
}
// refresh aggregate chart
charts[signal].RedrawAggregate();
if (signal == visibleSignal)
{
WriteableBitmap aggregateBitmapRef3 = vm.aggregateBitmap;
charts[visibleSignal].RefreshAggregate(ref aggregateBitmapRef3);
}
}
break;
}
}
catch (OperationCanceledException)
{
return;
}
},
new ExecutionDataflowBlockOptions
{
TaskScheduler = uiTask,
CancellationToken = cancelToken,
MaxDegreeOfParallelism = 4
});
return(GuiUpdates);
}