402 lines
15 KiB
C#
402 lines
15 KiB
C#
using GraphicData.Class;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.Contracts;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Data;
|
|
using System.Windows.Documents;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Windows.Navigation;
|
|
using System.Windows.Shapes;
|
|
|
|
namespace GraphicData.User_Control
|
|
{
|
|
|
|
public partial class uDataGraph : UserControl
|
|
{
|
|
public uDataGraph()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
#region Variables
|
|
int DataDurationStart = 0;
|
|
int DataDurationEnd = 0;
|
|
int DataDurationTotal = 0;
|
|
bool ReducedTimeStamps = false;
|
|
DateTime firstTime;
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public List<object[]> JsonData
|
|
{
|
|
get { return (List<object[]>)GetValue(JsonDataProperty); }
|
|
set { SetValue(JsonDataProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for JsonData. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty JsonDataProperty =
|
|
DependencyProperty.Register("JsonData", typeof(List<object[]>), typeof(uDataGraph), new PropertyMetadata(new List<object[]>(), new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public int IndexTime
|
|
{
|
|
get { return (int)GetValue(IndexTimeProperty); }
|
|
set { SetValue(IndexTimeProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for IndexTime. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty IndexTimeProperty =
|
|
DependencyProperty.Register("IndexTime", typeof(int), typeof(uDataGraph), new PropertyMetadata(0, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public int IndexValue
|
|
{
|
|
get { return (int)GetValue(IndexValueProperty); }
|
|
set { SetValue(IndexValueProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for IndexValue. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty IndexValueProperty =
|
|
DependencyProperty.Register("IndexValue", typeof(int), typeof(uDataGraph), new PropertyMetadata(1, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public int IndexDuration
|
|
{
|
|
get { return (int)GetValue(IndexDurationProperty); }
|
|
set { SetValue(IndexDurationProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for IndexDuration. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty IndexDurationProperty =
|
|
DependencyProperty.Register("IndexDuration", typeof(int), typeof(uDataGraph), new PropertyMetadata(2, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public int WarningThreshold
|
|
{
|
|
get { return (int)GetValue(WarningThresholdProperty); }
|
|
set { SetValue(WarningThresholdProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for WarningThreshold. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty WarningThresholdProperty =
|
|
DependencyProperty.Register("WarningThreshold", typeof(int), typeof(uDataGraph), new PropertyMetadata(40, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public int ErrorThreshold
|
|
{
|
|
get { return (int)GetValue(ErrorThresholdProperty); }
|
|
set { SetValue(ErrorThresholdProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for ErrorThreshold. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty ErrorThresholdProperty =
|
|
DependencyProperty.Register("ErrorThreshold", typeof(int), typeof(uDataGraph), new PropertyMetadata(60, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public bool IsThresholdActive
|
|
{
|
|
get { return (bool)GetValue(IsThresholdActiveProperty); }
|
|
set { SetValue(IsThresholdActiveProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for IsThresholdActive. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty IsThresholdActiveProperty =
|
|
DependencyProperty.Register("IsThresholdActive", typeof(bool), typeof(uDataGraph), new PropertyMetadata(false, new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
public string GraphicTitle
|
|
{
|
|
get { return (string)GetValue(GraphicTitleProperty); }
|
|
set { SetValue(GraphicTitleProperty, value); }
|
|
}
|
|
|
|
// Using a DependencyProperty as the backing store for GraphicTitle. This enables animation, styling, binding, etc...
|
|
public static readonly DependencyProperty GraphicTitleProperty =
|
|
DependencyProperty.Register("GraphicTitle", typeof(string), typeof(uDataGraph), new PropertyMetadata("CPU-Auslastung", new PropertyChangedCallback(HandleDependancyPropertyChanged)));
|
|
|
|
|
|
private static void HandleDependancyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if(!(d is uDataGraph me)) return;
|
|
me.BindingValueChange();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Binding
|
|
|
|
public void BindingValueChange()
|
|
{
|
|
if (JsonData == null || JsonData.Count <= 0) return;
|
|
GraphicCanvas.Children.Clear();
|
|
TimeStampGrid.Children.Clear();
|
|
TimeStampGrid.ColumnDefinitions.Clear();
|
|
GraphicDataProperty.Clear();
|
|
ReducedTimeStamps = false;
|
|
FillGraphicDataProperty();
|
|
FillVariables();
|
|
CreateDateTitle();
|
|
SetCanvasBorderPadding();
|
|
CreateTimeStamps();
|
|
DrawGraphicData();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GraphicDataProperty
|
|
|
|
public List<cGraphicData> GraphicDataProperty { get; set; } = new List<cGraphicData>();
|
|
|
|
public void FillGraphicDataProperty()
|
|
{
|
|
|
|
var reverseData = JsonData.ToList();
|
|
reverseData.Reverse();
|
|
|
|
if ((DateTime)reverseData[0][IndexTime] < (DateTime)reverseData[reverseData.Count() - 1][IndexTime])
|
|
{
|
|
foreach (var item in reverseData)
|
|
{
|
|
cGraphicData data = new cGraphicData();
|
|
data.DataValue = (double)item[IndexValue];
|
|
data.DataDuration = int.Parse(item[IndexDuration].ToString());
|
|
data.DataTime = (DateTime)item[IndexTime];
|
|
data.DataTime = data.DataTime.AddHours(2);
|
|
GraphicDataProperty.Add(data);
|
|
}
|
|
}
|
|
else if ((DateTime)JsonData[0][IndexTime] < (DateTime)JsonData[JsonData.Count() - 1][IndexTime])
|
|
{
|
|
foreach (var item in JsonData)
|
|
{
|
|
cGraphicData data = new cGraphicData();
|
|
data.DataValue = (double)item[IndexValue];
|
|
data.DataDuration = int.Parse(item[IndexDuration].ToString());
|
|
data.DataTime = (DateTime)item[IndexTime];
|
|
data.DataTime = data.DataTime.AddHours(2);
|
|
GraphicDataProperty.Add(data);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FillVariables
|
|
|
|
public void FillVariables()
|
|
{
|
|
firstTime = GraphicDataProperty.First<cGraphicData>().DataTime;
|
|
DateTime lastTime = GraphicDataProperty.Last<cGraphicData>().DataTime;
|
|
int lastDuration = GraphicDataProperty.Last<cGraphicData>().DataDuration;
|
|
|
|
lastTime = lastTime.AddMilliseconds(lastDuration);
|
|
|
|
DataDurationStart = firstTime.Hour;
|
|
if(lastTime.Minute != 0)
|
|
{
|
|
lastTime = lastTime.AddMinutes(60 - (lastDuration/60000));
|
|
}
|
|
DataDurationEnd = lastTime.Hour;
|
|
DataDurationTotal = DataDurationEnd - DataDurationStart;
|
|
if (firstTime.Day < lastTime.Day)
|
|
{
|
|
if (DataDurationTotal < 2)
|
|
{
|
|
DataDurationTotal = (24 - DataDurationStart) + DataDurationEnd;
|
|
}
|
|
}
|
|
|
|
if(DataDurationTotal > 10)
|
|
{
|
|
ReducedTimeStamps = true;
|
|
if(DataDurationTotal % 2 == 1)
|
|
{
|
|
DataDurationTotal += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Create Date Title
|
|
|
|
public void CreateDateTitle()
|
|
{
|
|
DateTime dataDate = GraphicDataProperty.First<cGraphicData>().DataTime;
|
|
dataDate = dataDate.Date;
|
|
DateBlock.Text = dataDate.ToString("dddd, dd.MM.yyyy");
|
|
TitleBlock.Text = GraphicTitle;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetCanvasBorderPadding
|
|
|
|
public void SetCanvasBorderPadding()
|
|
{
|
|
double borderWidth = GraphicBorder.ActualWidth;
|
|
double paddingWidth = borderWidth / (((double)DataDurationTotal + 1)* 2.0);
|
|
double borderHeight = GraphicBorder.ActualHeight;
|
|
double paddingHeight = borderHeight / 10.0;
|
|
GraphicBorder.Padding = new Thickness(0);
|
|
GraphicBorder.Padding = new Thickness(paddingWidth, paddingHeight - 4, paddingWidth, paddingHeight - 4);
|
|
GraphicBorder.UpdateLayout();
|
|
CanvasBorder.UpdateLayout();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Time Stamps
|
|
|
|
public void CreateTimeStamps()
|
|
{
|
|
SolidColorBrush customBrush = (SolidColorBrush)Application.Current.Resources["color9B9B9B"];
|
|
|
|
for (int i = 0; i <= DataDurationTotal; i++)
|
|
{
|
|
ColumnDefinition timeStamp = new ColumnDefinition();
|
|
timeStamp.Width = new GridLength(1, GridUnitType.Star);
|
|
TimeStampGrid.ColumnDefinitions.Add(timeStamp);
|
|
if (ReducedTimeStamps == true && i % 2 == 1)
|
|
{
|
|
continue;
|
|
}
|
|
TextBlock TimeStampText = new TextBlock()
|
|
{
|
|
Text = (firstTime.AddHours(i)).Hour.ToString() + ":00",
|
|
FontFamily = new FontFamily("Calibri"),
|
|
FontSize = 11,
|
|
HorizontalAlignment = HorizontalAlignment.Center,
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
Foreground = customBrush,
|
|
TextAlignment = TextAlignment.Center,
|
|
TextTrimming = TextTrimming.None,
|
|
};
|
|
if(DataDurationTotal > 20)
|
|
{
|
|
TimeStampText.Margin = new Thickness(-2,0,-2,0);
|
|
}
|
|
Grid.SetColumn(TimeStampText, i);
|
|
TimeStampGrid.Children.Add(TimeStampText);
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Draw Data
|
|
|
|
public double CalculateSetLeft(DateTime dataTime)
|
|
{
|
|
double setLeft = (double)dataTime.Hour + ((double)dataTime.Minute / 60.0);
|
|
setLeft = (setLeft - (double)DataDurationStart) * ((double)CanvasBorder.ActualWidth / ((double)DataDurationTotal));
|
|
return setLeft;
|
|
}
|
|
|
|
public void DrawGraphicData()
|
|
{
|
|
double setLeft = 0.0;
|
|
double setFactor = 0.0;
|
|
|
|
setFactor = (GraphicCanvas.ActualHeight - 8.0) / 100.0;
|
|
|
|
foreach (var data in GraphicDataProperty)
|
|
{
|
|
|
|
DateTime dataTime = data.DataTime;
|
|
double dataValue = data.DataValue;
|
|
int dataDuration = data.DataDuration;
|
|
|
|
Border border = new Border
|
|
{
|
|
Height = 8.0,
|
|
Width = (double)dataDuration * ((double)CanvasBorder.ActualWidth / ((double)DataDurationTotal)) / 3600000.0,
|
|
CornerRadius = new CornerRadius(4.0),
|
|
ToolTip = dataTime.ToShortTimeString() + " - " + dataTime.AddMilliseconds(dataDuration).ToShortTimeString() + " | " + (int)dataValue + "%"
|
|
};
|
|
if(border.Width < 8)
|
|
{
|
|
border.Width = 8;
|
|
}
|
|
if(IsThresholdActive == false)
|
|
{
|
|
border.Background = new SolidColorBrush(Color.FromRgb(0, 157, 221));
|
|
}
|
|
else if(dataValue >= ErrorThreshold)
|
|
{
|
|
border.Background = new SolidColorBrush(Color.FromRgb(206, 61, 54));
|
|
}
|
|
else if(dataValue >= WarningThreshold)
|
|
{
|
|
border.Background = new SolidColorBrush(Color.FromRgb(251, 157, 40));
|
|
}
|
|
else
|
|
{
|
|
border.Background = new SolidColorBrush(Color.FromRgb(117, 177, 89));
|
|
}
|
|
setLeft = CalculateSetLeft(dataTime);
|
|
Canvas.SetBottom(border, dataValue * setFactor);
|
|
Canvas.SetLeft(border, setLeft);
|
|
GraphicCanvas.Children.Add(border);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Close Button
|
|
|
|
private void Border_MouseEnter(object sender, MouseEventArgs e)
|
|
{
|
|
SolidColorBrush customBrush = (SolidColorBrush)Application.Current.Resources["color009DDD"];
|
|
CloseButton.PrimaryIconColor = customBrush;
|
|
}
|
|
|
|
private void Border_MouseLeave(object sender, MouseEventArgs e)
|
|
{
|
|
SolidColorBrush customBrush = (SolidColorBrush)Application.Current.Resources["color9B9B9B"];
|
|
CloseButton.PrimaryIconColor = customBrush;
|
|
}
|
|
|
|
private void Border_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
Close_Window();
|
|
}
|
|
|
|
private void Border_TouchDown(object sender, TouchEventArgs e)
|
|
{
|
|
Close_Window();
|
|
}
|
|
|
|
private Window GetMainWindow()
|
|
{
|
|
DependencyObject parent = VisualTreeHelper.GetParent(this);
|
|
|
|
while (parent != null && !(parent is Window))
|
|
{
|
|
parent = VisualTreeHelper.GetParent(parent);
|
|
}
|
|
|
|
return parent as Window;
|
|
}
|
|
|
|
private void Close_Window()
|
|
{
|
|
|
|
Window mainWindow = Window.GetWindow(this);
|
|
|
|
if (mainWindow != null)
|
|
{
|
|
mainWindow.Close();
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|