using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using System.IO;
using System.Globalization;
using System.Threading;
namespace BoerseMonitor
{
struct ChartData
{
public string ChartPeriod;
public string CurrCouple; //Currency InfoData
public string FileName;
}
public partial class BoerseMonitor : Form
{
private List CSVStruct = new List();
private List SMAIndikator = new List();
private List Indikators = new List();
private List HeighValue = new List();
private List LowValue = new List();
private ChartData UserData;
private ChartLabel UserChartLabel;
private Graphics UserChart;
private Panel pnlChart = new Panel(); // Diagramm
private ToolStripButton[] btnPeriod = new ToolStripButton[6];
private ToolStripLabel lbPlus;
private ToolStripLabel lbMinus;
private ToolStripLabel lbScaleCancel;
private ToolStripLabel lbCursor;
private ToolStripSeparator[] spTools = new ToolStripSeparator[5];
private ToolStripSeparator[] spTimeInterval = new ToolStripSeparator[6];
private int[] TimeInterval = new int[] { 1, 5, 15, 30, 60, 240, 1440, 10080, 43200 };
private Grid UserGrid;
private int SMAPeriod = 0;
private int GridStep = 45;
private int ValueStep;
private int DateStep;
private int DateCoord = 0;
private Color ColorBack = Color.Black;
private InfoData ChartData;
private Cursor PanelCursor = Cursor.Current;
public Label[] lbValue;
public Label[] lbDate;
public int AmountElement;
public static int Scaling = 1;
public int Shift = 0;
public bool ScaleBtn = false;
public static DirectoryInfo DirInfo;
public static int StepSchift = 100;
public ChartValue[] Dates;
public int LabelRound = 5;
public BoerseMonitor()
{
InitializeComponent();
pnlChart.Name = "UserChart";
pnlChart.Location = new Point(5, 20);
pnlChart.BorderStyle = BorderStyle.Fixed3D;
pnlChart.Cursor = PanelCursor;
this.tbChart.Controls.Add(pnlChart);
pnlChart.Paint += new System.Windows.Forms.PaintEventHandler(this.PanelChartPaint);
pnlChart.Width = (tbChart.Width / GridStep - 2) * GridStep;
pnlChart.Height = (this.tbChart.Height / GridStep - 3) * GridStep;
DateStep = this.pnlChart.Width / GridStep;
ValueStep = this.pnlChart.Height / GridStep;
lbValue = new Label[ValueStep];
lbDate = new Label[DateStep];
UserChart = this.pnlChart.CreateGraphics();
UserChart.Clear(ColorBack);
UserGrid = new Grid(UserChart, Color.Green, ColorBack, pnlChart.Width, pnlChart.Height, GridStep);
for (int i = 0; i < 6; i++)
{
btnPeriod[i] = new ToolStripButton();
btnPeriod[i].Size = new System.Drawing.Size(25, 22);
btnPeriod[i].Name = "M" + TimeInterval[i].ToString();
btnPeriod[i].ForeColor = Color.Black;
btnPeriod[i].Checked = true;
btnPeriod[i].CheckOnClick = true;
btnPeriod[i].Checked = false;
if (i == 0)
{
btnPeriod[i].Checked = true;
UserData.ChartPeriod = btnPeriod[i].Name;
btnPeriod[i].ForeColor = Color.Orange;
}
btnPeriod[i].DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text;
btnPeriod[i].Click += new System.EventHandler(this.TimeIntervalClick);
toolStrip1.Items.Add(btnPeriod[i]);
}
for (int i = 0; i < 6; i++)
{
if (TimeInterval[i] < 60)
{
btnPeriod[i].Text = "M" + TimeInterval[i];
btnPeriod[i].ToolTipText = TimeInterval[i].ToString() + " Min.";
}
else
{
btnPeriod[i].Text = "H" + TimeInterval[i] / 60;
btnPeriod[i].ToolTipText = (TimeInterval[i] / 60).ToString() + " St.";
}
}
//--------------------------------SCALIRUNG---------------------------------------------------
spTools[0] = new ToolStripSeparator();
toolStrip1.Items.Add(spTools[0]);
lbPlus = new ToolStripLabel();
lbPlus.Name = "lbPlus";
lbPlus.Size = new System.Drawing.Size(32, 32);
lbPlus.Image = Properties.Resources.Plus;
lbPlus.Visible = true;
lbPlus.Enabled = false;
lbPlus.ToolTipText = "Plus";
lbPlus.Click += new System.EventHandler(this.PlusMinusClick);
toolStrip1.Items.Add(lbPlus);
lbMinus = new ToolStripLabel();
lbMinus.Name = "lbMinus";
lbMinus.Size = new System.Drawing.Size(32, 32);
lbMinus.Image = Properties.Resources.Minus;
lbMinus.Visible = true;
lbMinus.Enabled = false;
lbMinus.ToolTipText = "Minus";
lbMinus.Click += new System.EventHandler(this.PlusMinusClick);
toolStrip1.Items.Add(lbMinus);
spTools[3] = new ToolStripSeparator();
lbScaleCancel = new ToolStripLabel();
lbScaleCancel.Size = new System.Drawing.Size(25, 22);
lbScaleCancel.Image = Properties.Resources.Reset;
lbScaleCancel.Name = "lbCancel";
lbScaleCancel.ToolTipText = "Reset";
lbScaleCancel.Visible = true;
lbScaleCancel.Enabled = false;
lbScaleCancel.Click += new System.EventHandler(this.PlusMinusClick);
toolStrip1.Items.Add(lbScaleCancel);
spTools[4] = new ToolStripSeparator();
lbCursor = new ToolStripLabel();
lbCursor.Name = "lbCursor";
lbCursor.Size = new System.Drawing.Size(32, 32);
lbCursor.Image = Properties.Resources.CursorK;
lbCursor.Visible = true;
lbCursor.Enabled = false;
lbCursor.ToolTipText = "Cursor";
lbCursor.Click += new System.EventHandler(this.btnCursorClick);
toolStrip1.Items.Add(lbCursor);
for (int i = 0; i < ValueStep; i++)
{
lbValue[i] = new Label();
lbValue[i].Text = "";
lbValue[i].Name = "lblValue" + i.ToString();
lbValue[i].Location = new Point(pnlChart.Width + 5 , ((i + 1) * GridStep + 10));
lbValue[i].Font = new Font("Microsoft Sans Serif", 7);
lbValue[i].Size = new System.Drawing.Size(35, 13);
lbValue[i].AutoSize = true;
lbValue[i].Visible = true;
this.tbChart.Controls.Add(lbValue[i]);
}
DateCoord = pnlChart.Location.X;
for (int j = 0; j < DateStep; j++)
{
lbDate[j] = new Label();
lbDate[j].Text = "";
lbDate[j].Location = new Point(pnlChart.Location.X + j * GridStep - 3,
pnlChart.Height + 25);
lbDate[j].Visible = true;
lbDate[j].Name = "label" + j.ToString();
lbDate[j].Size = new System.Drawing.Size(35, 13);
lbDate[j].Font = new Font("Microsoft Sans Serif", 7);
lbDate[j].AutoSize = true;
this.tbChart.Controls.Add(lbDate[j]);
}
}
//---------------------------Skalierung--------------------------------------------------------
private void PlusMinusClick(object sender, EventArgs e)
{
ToolStripLabel tlsItem = (ToolStripLabel)sender;
if (tlsItem.Name == "lbCancel")
{
Scaling = 1;
lbScaleCancel.Enabled = false;
lbMinus.Enabled = false;
Shift = 0;
}
if (tlsItem.Name == "lbPlus")
{
Scaling +=10;
lbMinus.Enabled = true;
if (Scaling > 100) lbPlus.Enabled = false;
lbScaleCancel.Enabled = true;
}
if (tlsItem.Name == "lbMinus" && Scaling > 1)
{
Scaling -=10;
lbPlus.Enabled = true;
lbScaleCancel.Enabled = true;
if (Scaling == 1)
{
lbMinus.Enabled = false;
lbScaleCancel.Enabled = false;
}
}
UserChartLabel = new ChartLabel(Dates, pnlChart.Width, lbDate, lbValue, DateStep, ValueStep);
UserChartLabel.Run(AmountElement, Shift, Scaling, GridStep, LabelRound);
UserChart.Clear(ColorBack);
if (this.c_Gitter.Checked == true) UserGrid.DrawingGrid();
if (Dates != null) Drawing();
}
//----------------------------------------------------------------------------------------------
protected override void OnPaint(PaintEventArgs e)
{
// base.OnPaint(e);
}
private void DateClear()
{
Array.Clear(Dates, 0, Dates.Length);
AmountElement = 0;
Shift = 0;
Scaling = 1;
}
//-----------------------------------------------------------------------------------------------
private void CoupleClick(object sender, EventArgs e)
{
if (Dates != null) DateClear();
if (sender.GetType().Name != "ToolStripButton")
{
SMAPeriod = 0;
SMAIndikator.Clear();
Indikators.Clear();
HeighValue.Clear();
LowValue.Clear();
}
if (sender.GetType().ToString() == "System.Windows.Forms.ToolStripMenuItem")
{
UserData.CurrCouple = sender.ToString();
}
DirInfo = Directory.GetParent(Application.StartupPath).Parent.Parent;
UserData.FileName = DirInfo.FullName + "\\MetaTrader\\" +
UserData.CurrCouple + UserData.ChartPeriod + ".csv";
try
{
ChartData = new InfoData(UserData.FileName, ',');
Dates = ChartData.Extract();
}
catch (DirectoryNotFoundException)
{
string error = "Verzeichnis nicht gefunden: " + Application.StartupPath + "\\MetaTrader\\";
MessageBox.Show(error, "Achtung", MessageBoxButtons.OK, MessageBoxIcon.Information);
UserData.FileName = null;
return;
}
catch (FileNotFoundException)
{
string error = "Datei nicht gefunden: " + UserData.FileName;
MessageBox.Show(error, "Achtung", MessageBoxButtons.OK, MessageBoxIcon.Information);
UserData.FileName = null;
return;
}
catch (IOException)
{
MessageBox.Show("", "Achtung", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
if (Dates != null)
{
AmountElement = Dates.Length;
trckMoveStep.Maximum = 1000;
trckMoveStep.Value = StepSchift;
grdDate.DataSource = ChartData.ReadCSVFile();
UserChart.Clear(ColorBack);
if (this.c_Gitter.Checked == true) UserGrid.DrawingGrid();
UserChartLabel = new ChartLabel(Dates, pnlChart.Width, lbDate, lbValue, DateStep, ValueStep);
UserChartLabel.Run(AmountElement, Shift, Scaling, GridStep, LabelRound);
Drawing();
ScaleBtn = true;
grdDate.Visible = true;
lbCoupleInterval.Text = UserData.CurrCouple + ' ' + UserData.ChartPeriod;
pnlChart.Cursor = Cursors.Arrow;
PanelCursor = Cursors.Arrow;
btnLeftMove.Visible = ScaleBtn;
lbPlus.Enabled = ScaleBtn;
lbCoupleInterval.Visible = true;
lbCursor.Enabled = true;
tlsIndikator.Enabled = true;
}
}
//-------------------------------------------------------------------------
private void AddSMAIndikator(object sender, EventArgs e)
{
int Index = -1;
ToolStripMenuItem mnuItem = (ToolStripMenuItem)sender;
string[] Period = mnuItem.Text.Split(' ');
SMAPeriod = Int32.Parse(Period[1]);
if (Dates == null)
{
string error = "Datei " + UserData.FileName + "ist leer";
MessageBox.Show(error, "Achtung", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
if (Indikators.Count != 0)
{
Index = Indikators.BinarySearch(SMAPeriod);
}
if (Index < 0)
{
Indikators.Add(SMAPeriod);
DrawIndikator();
}
}
//--------------------------------------------------------------------------------------
private void DrawIndikator()
{
float XFaktor;
float YFaktor;
double Max;
double Min;
int i;
int ChartBegin = AmountElement - pnlChart.Width / Scaling + Shift;
int ChartEnd = AmountElement + Shift;
Color ColorIndikator;
Application.DoEvents();
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
CalculationSMA();
Max = 0;
Min = float.MaxValue;
switch (SMAPeriod)
{
case 13:
ColorIndikator = Color.Yellow;
break;
case 22:
ColorIndikator = Color.Blue;
break;
case 34:
ColorIndikator = Color.Green;
break;
case 55:
ColorIndikator = Color.Pink;
break;
case 144:
ColorIndikator = Color.Magenta;
break;
default:
ColorIndikator = Color.Red;
break;
}
Pen py = new Pen(ColorIndikator, 1);
for (i = 0; i <= SMAIndikator.Count - 1; i++)
{
if (Convert.ToDouble(SMAIndikator[i], provider) > Max) Max = Convert.ToDouble(SMAIndikator[i], provider);
if (Convert.ToDouble(SMAIndikator[i], provider) < Min) Min = Convert.ToDouble(SMAIndikator[i], provider);
}
YFaktor = (float)(pnlChart.Height / (Max - Min));
XFaktor = (float)pnlChart.Width / SMAIndikator.Count;
int CountElement = ChartBegin;
for (int j = 0; j < SMAIndikator.Count - 1; j++)
{
UserChart.DrawLine(py, (float)(j * XFaktor),
(float)(pnlChart.Height - (Convert.ToDouble(this.SMAIndikator[j], provider) - Min) * YFaktor),
(j + 1) * XFaktor,
(float)(pnlChart.Height - (Convert.ToDouble(this.SMAIndikator[j + 1], provider) - Min) * YFaktor));
CountElement++;
}
}
//------------------------------------------------------------------------------------------
private void CalculationSMA()
{
double SMASum;
int ChartBegin = AmountElement - pnlChart.Width / Scaling + Shift;
int ChartEnd = AmountElement + Shift;
if (Shift != 0 || Shift > StepSchift) ScaleBtn = false;
if (AmountElement < SMAPeriod) ScaleBtn = false;
SMAIndikator.Clear();
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
for (int i = ChartBegin; i < ChartEnd - SMAPeriod; i++)
{
SMASum = 0;
for (int k = i + SMAPeriod -1 ; k >i; k--)
{
SMASum += Convert.ToDouble(Dates[k].Close, provider);
}
SMAIndikator.Add(SMASum / SMAPeriod);
}
}
//------------------------------------------------------------------------------------------
private void CalculationHeightLow()
{
double Max;
double Min;
float XFaktor;
float YFaktor;
int i;
int m;
int k;
Pen pn = new Pen(Color.Red, 1);
Application.DoEvents();
if (Shift != 0) return;
if (AmountElement < 21) return;
HeighValue.Clear();
LowValue.Clear();
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
int Point = pnlChart.Width / Scaling;
int ElementInterval = AmountElement + Shift;
i = ElementInterval - Point;
while (i < (ElementInterval - 22))
{
m = i;
Min = Convert.ToDouble(Dates[i].Heigth, provider);
Max = Convert.ToDouble(Dates[i].Low, provider);
for (k = 0; k < 21; k++)
{
if (Convert.ToDouble(Dates[m].Heigth, provider) > Max)
{
Max = Convert.ToDouble(Dates[m].Heigth, provider);
}
if (Convert.ToDouble(Dates[m].Low, provider) < Min)
{
Min = Convert.ToDouble(Dates[m].Low, provider);
}
m++;
}
i+= 21;
for (k = 0; k < 21; k++)
{
HeighValue.Add(Max);
LowValue.Add(Min);
}
}
Max = 0;
Min = float.MaxValue;
Pen pb = new Pen(Color.Blue, 1);
Pen pg = new Pen(Color.Magenta, 1);
for (i = ElementInterval - Point; i < ElementInterval; i++)
{
if (Convert.ToDouble(Dates[i].Close, provider) > Max)
Max = Convert.ToDouble(Dates[i].Close, provider);
if (Convert.ToDouble(Dates[i].Close, provider) < Min)
Min = Convert.ToDouble(Dates[i].Close, provider);
}
YFaktor = (float)(pnlChart.Height / (Max - Min));
XFaktor = (float)pnlChart.Width / HeighValue.Count;
for (int j = 0; j < HeighValue.Count - 1; j++)
UserChart.DrawLine(pb, (float)(j * XFaktor),
(float)(pnlChart.Height - ((float)this.HeighValue[j] - Min) * YFaktor),
(j + 1) * XFaktor,
(float)(pnlChart.Height - ((float)this.HeighValue[j + 1] - Min) * YFaktor));
YFaktor = (float)(pnlChart.Height / (Max - Min));
XFaktor = (float)pnlChart.Width / LowValue.Count;
for (int j = 0; j < LowValue.Count - 1; j++)
UserChart.DrawLine(pg, (float)(j * XFaktor),
(float)(pnlChart.Height - ((float)this.LowValue[j] - Min) * YFaktor),
(j + 1) * XFaktor,
(float)(pnlChart.Height - ((float)this.LowValue[j + 1] - Min) * YFaktor));
}
//----------------------------------------------------------------------------------------------
private void PanelChartPaint(object sender, PaintEventArgs e)
{
UserChart = this.pnlChart.CreateGraphics();
UserChart.Clear(ColorBack);
if (this.c_Gitter.Checked == true) UserGrid.DrawingGrid();
if (Dates != null) Drawing();
}
//--------------------------------------------------------------------------------------------
private void TimeIntervalClick(object sender, EventArgs e)
{
ToolStripButton btnTimeInterval = (ToolStripButton)sender;
UserData.ChartPeriod = btnTimeInterval.Name;
for (int i = 0; i < 6; i++)
{
btnPeriod[i].Checked = false;
btnPeriod[i].ForeColor = Color.Black;
}
btnTimeInterval.Checked = true;
UserData.ChartPeriod = btnTimeInterval.Name;
btnTimeInterval.ForeColor = Color.Orange;
if (Dates != null)
{
CoupleClick(sender, e);
lbPlus.Enabled = true;
lbMinus.Enabled = false;
lbScaleCancel.Enabled = false;
Scaling = 1;
Shift = 0;
}
pnlChart.Cursor = Cursors.Arrow;
PanelCursor = Cursors.Arrow;
lbCursor.Image = Properties.Resources.CursorK;
lbCursor.ToolTipText = "Cursor";
}
//-------------------------------------------------------------------------
private void beendenToolStripMenuItem1_Click(object sender, EventArgs e)
{
Close();
}
//-------------------------------------------------------------------------
private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
{
About fa = new About();
fa.ShowDialog();
}
//------------------------------------------------------------------------
public void Drawing ()
{
float XFaktor;
float YFaktor;
double Max;
double Min;
int i;
int ChartBegin = AmountElement - pnlChart.Width / Scaling + Shift;
int ChartEnd = AmountElement + Shift;
Application.DoEvents();
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
Max = 0;
Min = float.MaxValue;
for (i = ChartBegin; i <= ChartEnd - 1; i++)
{
if (Convert.ToDouble(Dates[i].Close , provider) > Max)
Max = Convert.ToDouble(Dates[i].Heigth, provider);
if (Convert.ToDouble(Dates[i].Close, provider) < Min)
Min = Convert.ToDouble(Dates[i].Low, provider);
}
YFaktor = (float)(pnlChart.Height /(Max - Min) );
XFaktor = (float)pnlChart.Width / (ChartEnd - ChartBegin);
Pen pn = new Pen(Color.Red, 1);
Pen pax = new Pen(Color.Black, 2);
Pen p = new Pen(Color.White, 1);
if (this.rbtnLinie.Checked == true)
{
int CountElement = ChartBegin;
for (i = 0; i <= ChartEnd - ChartBegin - 2; i++)
{
UserChart.DrawLine(pn, (float)(i * XFaktor),
(float)(pnlChart.Height - (Convert.ToDouble(Dates[CountElement].Close, provider) - Min) * YFaktor),
(i + 1) * XFaktor,
(float)(pnlChart.Height - (Convert.ToDouble(Dates[CountElement + 1].Close, provider) - Min) * YFaktor));
CountElement++;
}
}
else
{
float x1;
float y1 = 0;
int HeigthCandle;
int WidthCandle = 1;
Color col_br = Color.Lime;
Pen pl = new Pen(Color.Lime, 1);
int CountElement = ChartBegin;
int Count_x = 0;
for (i = ChartBegin; i <= ChartEnd - 1; i++)
{
if (Scaling > 20) WidthCandle = 3;
if (Scaling > 40) WidthCandle = 6;
if (Convert.ToDouble(Dates[i].Close, provider) > Convert.ToDouble(Dates[i].Open, provider))
col_br = Color.Lime;
if (Convert.ToDouble(Dates[i].Close, provider) <= Convert.ToDouble(Dates[i].Open, provider))
col_br = Color.Red;
SolidBrush ob = new SolidBrush(col_br);
HeigthCandle = (int)(Math.Abs(Convert.ToDouble(Dates[i].Close, provider) -
Convert.ToDouble(Dates[i].Open, provider)) * YFaktor);
if (HeigthCandle == 0) HeigthCandle = 2;
x1 = (float)((Count_x * XFaktor) - WidthCandle / 2);
if (Convert.ToDouble(Dates[i].Close, provider) > Convert.ToDouble(Dates[i].Open, provider))
y1 = (float)(pnlChart.Height - (Convert.ToDouble(Dates[i].Close, provider) - Min) * YFaktor);
if (Convert.ToDouble(Dates[i].Close, provider) <= Convert.ToDouble(Dates[i].Open, provider))
y1 = (float)(pnlChart.Height - (Convert.ToDouble(Dates[i].Open, provider) - Min) * YFaktor);
UserChart.DrawLine(pl, (float)(Count_x * XFaktor),
(float)(pnlChart.Height - (Convert.ToDouble(Dates[i].Heigth, provider) - Min) * YFaktor),
(float)(Count_x * XFaktor),
(float)(pnlChart.Height - (Convert.ToDouble(Dates[i].Low, provider) - Min) * YFaktor));
UserChart.FillRectangle(ob, x1, y1, WidthCandle, HeigthCandle);
Count_x++;
}
}
foreach (int Period in Indikators)
{
if (Period != 0) SMAPeriod = Period;
DrawIndikator();
}
if (HeighValue.Count != 0) CalculationHeightLow();
if (this.c_Volumen.Checked == true) DrawVolumen();
DrawString();
}
//-----------------------------------------------------------------------------
public void DrawString()
{
lbCurrPair.Text = UserData.CurrCouple + ' ' + UserData.ChartPeriod;
lbCurrPair.Visible = true;
}
//----------------------------------------------------------------------------------
public void DrawVolumen()
{
int max, min;
float XFaktor;
float YFaktor;
float x1;
float y1 = 0;
int heigth;
int width = 1;
if (Shift != 0) return;
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
Color col_br = Color.Blue;
SolidBrush ob = new SolidBrush(col_br);
max = 0;
min = int.MaxValue;
for (int i =0; i <= AmountElement - 1; i++)
{
if (Convert.ToInt32(Dates[i].Volumen, provider) > max) max = Convert.ToInt32(Dates[i].Volumen, provider);
if (Convert.ToInt32(Dates[i].Volumen, provider) < min) min = Convert.ToInt32(Dates[i].Volumen, provider);
}
YFaktor = (float)((pnlChart.Height / 10.0) / (max - min));
XFaktor = (float)pnlChart.Width / AmountElement;
for (int i = 0; i < AmountElement - 1; i++)
{
if (Scaling > 20) width = 3;
if (Scaling > 40) width = 6;
for (i =0; i < AmountElement - 1; i++)
{
heigth = (int)(Convert.ToDouble(Dates[i].Volumen, provider) * YFaktor);
x1 = (float)(i * XFaktor);
y1 = (float)(pnlChart.Height - (Convert.ToDouble(Dates[i].Volumen, provider) - min) * YFaktor);
UserChart.FillRectangle(ob, x1, y1, width, heigth);
}
}
}
//-------------------------------------------------------------------------------------
private void eingeschaftenToolStripMenuItem_Click(object sender, EventArgs e)
{
this.tbIWorkSpace.SelectedIndex = 1;
}
//-------------------------------------------------------------------------------------
private void cmb_Ober_SelectedIndexChanged(object sender, EventArgs e)
{
int selectedIndex = this.cmb_Ober.SelectedIndex;
switch (selectedIndex)
{
case 0: BackColor = Color.Black;
break;
case 1: BackColor = Color.Gray;
break;
default: BackColor = Color.Black;
break;
}
UserChart.Clear(BackColor);
UserGrid = new Grid(UserChart, Color.Green, BackColor, pnlChart.Width, pnlChart.Height, GridStep);
}
//----------------------------------------------------------
private void btnMoveClick(object sender, EventArgs e)
{
Button btnMove = (Button)sender;
Application.DoEvents();
UserChart.Clear(ColorBack);
if (this.c_Gitter.Checked == true) UserGrid.DrawingGrid();
if (btnMove.Name == "btnRightMove")
{
if (btnLeftMove.Visible == false) btnLeftMove.Visible = true;
Shift += StepSchift;
if (Shift > 0) Shift = 0;
if (Shift == 0) btnRightMove.Visible = false;
}
if (btnMove.Name == "btnLeftMove")
{
if (Math.Abs(Shift) < AmountElement)
{
Shift -= StepSchift;
if (AmountElement - Math.Abs(Shift) < 0)
{
btnLeftMove.Visible = false;
Shift = pnlChart.Width / Scaling - AmountElement;
}
if (!btnRightMove.Visible) btnRightMove.Visible = true;
}
else
{
btnLeftMove.Visible = false;
return;
}
}
UserChartLabel = new ChartLabel(Dates, pnlChart.Width, lbDate, lbValue, DateStep, ValueStep);
UserChartLabel.Run(AmountElement, Shift, Scaling, GridStep, LabelRound);
if (Dates != null) Drawing ();
}
//---------------------------------------------------------------------------------
private void btnCursorClick(object sender, EventArgs e)
{
if (PanelCursor == Cursors.Arrow)
{
pnlChart.Cursor = Cursors.Cross;
PanelCursor = Cursors.Cross;
lbCursor.Image = Properties.Resources.CursorD;
lbCursor.ToolTipText = "Cursor";
}
else
{
pnlChart.Cursor = Cursors.Arrow;
PanelCursor = Cursors.Arrow;
lbCursor.Image = Properties.Resources.CursorK;
lbCursor.ToolTipText = "Cursor";
}
}
//---------------------------------------------------------------------------------
private void tlsHLInd_Click(object sender, EventArgs e)
{
CalculationHeightLow();
}
//---------------------------------------------------------------------------------
private void trckMoveStep_ValueChanged(object sender, EventArgs e)
{
StepSchift = trckMoveStep.Value;
lbStepValue.Text = StepSchift.ToString();
}
}
}
//-------------------------------------------------------------------------------------------------
class ChartLabel
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing;
namespace BoerseMonitor
{
class ChartLabel
{
private int ChartWidth;
public ChartValue[] lblValue;
private Label[] lbDate;
private Label[] lbValue;
private int DateStep;
private int ValueStep;
public List Year;
public List MonthDay;
public List YearMonthDay;
public List HourMin;
//---------------------------------------------------------------------------
public ChartLabel(ChartValue[] lblValue, int ChartWidth, Label[] lbDate, Label[] lbValue, int DateStep, int ValueStep)
{
this.lblValue = lblValue;
this.ChartWidth = ChartWidth;
this.lbDate = lbDate;
this.lbValue = lbValue;
this.DateStep = DateStep;
this.ValueStep = ValueStep;
Year = new List();
MonthDay = new List();
YearMonthDay = new List();
HourMin = new List();
}
//---------------------------------------------------------------------------
private double FindMaxValue(List UserList)
{
if (UserList.Count == 0)
{
throw new InvalidOperationException("Liste ist leer! ");
}
double maxValue = Double.MinValue;
foreach (double Param in UserList)
{
if (Param > maxValue)
{
maxValue = Param;
}
}
return maxValue;
}
//-------------------------------------------------------------
private double FindMinValue(List UserList)
{
if (UserList.Count == 0)
{
throw new InvalidOperationException("Liste ist leer! ");
}
double minValue = Double.MaxValue;
foreach (double Param in UserList)
{
if (Param < minValue)
{
minValue = Param;
}
}
return minValue;
}
//---------------------------------------------------------------------------
public void Run(int CountElemetnt, int Shift, int Scaling, int GridInterval, int Round)
{
string Label;
int KoefLabel;
int GridStepKoef = GridInterval / Scaling;
if (GridInterval <= 30) KoefLabel = 4;
else KoefLabel = 2;
if (CountElemetnt == 0) return;
int Point = ChartWidth / Scaling;
int ElementInterval = CountElemetnt + Shift;
if (ElementInterval < 0) ElementInterval = Point;
if (ElementInterval < Point) Point = ElementInterval;
for (int i = ElementInterval - Point; i < ElementInterval; i++)
{
string[] InterimStorage;
string[] YMD;
InterimStorage = this.lblValue[i].DateTime.Split(' ');
YearMonthDay.Add(InterimStorage[0]);
HourMin.Add(InterimStorage[1]);
YMD = InterimStorage[0].Split('.');
Year.Add(YMD[0]);
MonthDay.Add(YMD[1] + '.' + YMD[2]);
}
for (int i = 0; i < DateStep - 1; i += KoefLabel)
{
if (i == 0)
this.lbDate[i].Text = YearMonthDay[0];
else
this.lbDate[i].Text = MonthDay[i * GridStepKoef] + ' ' + HourMin[i * GridStepKoef];
}
List IntervalHeigthValue = new List();
List IntervalLowValue = new List();
for (int i = ElementInterval - Point; i < ElementInterval; i++)
{
IntervalHeigthValue.Add(Convert.ToDouble(lblValue[i].Heigth.Replace('.', ',')));
IntervalLowValue.Add(Convert.ToDouble(lblValue[i].Low.Replace('.', ',')));
}
double MaxLabel = FindMaxValue(IntervalHeigthValue);
double MinLabel = FindMinValue(IntervalLowValue);
double StepLabel = (MaxLabel - MinLabel) / ValueStep;
StepLabel = Math.Round(StepLabel, Round);
MaxLabel = Math.Round(MaxLabel, Round);
MinLabel = Math.Round(MinLabel, Round);
int Count = ValueStep - 1;
for (int j = 0; j < ValueStep; j++)
{
Label = Convert.ToString(MinLabel + j * StepLabel);
this.lbValue[Count].Text = Label;
Count--;
}
}
}
}
class InfoData
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Data;
using System.Windows.Forms;
namespace BoerseMonitor
{
public struct ChartValue
{
public string DateTime;
public string Open;
public string Heigth;
public string Low;
public string Close;
public string Volumen;
}
class InfoData
{
private string FileName;
private char Delimiter;
private string[] Filds;
private ChartValue[] Dates;
public InfoData(string FileName, char Delimiter)
{
this.FileName = FileName;
this.Delimiter = Delimiter;
}
//-----------------------------------------------------------------------------
public ChartValue[] Extract()
{
this.Filds = File.ReadAllLines(FileName);
Dates = new ChartValue[Filds.Length];
for (int i = 0; i < Filds.Length; i++)
{
string[] Record = Filds[i].Split(Delimiter);
Dates[i].DateTime = Record[0];
Dates[i].Open = Record[1];
Dates[i].Heigth = Record[2];
Dates[i].Low = Record[3];
Dates[i].Close = Record[4];
Dates[i].Volumen = Record[5];
}
return Dates;
}
//------------------------------------------------------------------------------------------
public DataTable ReadCSVFile()
{
string[] DateTime;
DataTable SoureTable = new DataTable("Couple");
DataColumn clDate;
clDate = new DataColumn("DATE", typeof(String));
DataColumn clTime;
clTime = new DataColumn("TIME", typeof(String));
DataColumn clOpen;
clOpen = new DataColumn("OPEN", typeof(String));
DataColumn clHeight;
clHeight = new DataColumn("HEIGHT", typeof(String));
DataColumn clLow;
clLow = new DataColumn("LOW", typeof(String));
DataColumn clClose;
clClose = new DataColumn("CLOSE", typeof(String));
DataColumn clVol;
clVol = new DataColumn("VOLUMEN", typeof(String));
SoureTable.Columns.AddRange(new DataColumn[] { clDate, clTime, clOpen, clHeight, clLow, clClose, clVol });
try
{
DataRow Record = null;
for (int i = 0; i < Dates.Length; i++)
{
Record = SoureTable.NewRow();
DateTime = Dates[i].DateTime.Split(' ');
Record["DATE"] = DateTime[0];
Record["TIME"] = DateTime[1];
Record["OPEN"] = Dates[i].Open;
Record["HEIGHT"] = Dates[i].Heigth;
Record["LOW"] = Dates[i].Low;
Record["CLOSE"] = Dates[i].Close;
Record["VOLUMEN"] = Dates[i].Volumen;
SoureTable.Rows.Add(Record);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return SoureTable;
}
}
}
class Grid
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
using System.Drawing.Drawing2D;
namespace BoerseMonitor
{
class Grid
{
protected Graphics Chart;
protected Color PenColor;
protected Color BackraudColor;
protected int Width;
protected int Height;
protected int GridInterval;
private Pen GridLine;
private Pen LineMark;
public Grid(Graphics Chart, Color PenColor, Color BackraudColor, int Width, int Height, int GridInterval)
{
this.Chart = Chart;
this.PenColor = PenColor;
this.BackraudColor = BackraudColor;
this.Width = Width;
this.Height = Height;
this.GridInterval = GridInterval;
Init(BackraudColor, PenColor);
}
//---------------------------------------------------------------------------------------------------------
public void DrawingGrid()
{
for (int i = 1; i < Height / GridInterval; i++)
this.Chart.DrawLine(GridLine, 0, i * GridInterval, Width, i * GridInterval);
for (int i = 1; i < Width / GridInterval; i++)
this.Chart.DrawLine(GridLine, i * GridInterval, 0, i * GridInterval, Height);
DrawMark();
}
//-----------------------------------------------------------------------------------------------------------
public void DrawMark()
{
int KoefLabel;
if (GridInterval <= 30)
KoefLabel = 4;
else
KoefLabel = 2;
for (int i = 1; i < Height / GridInterval; i++)
this.Chart.DrawLine(LineMark, Width - 7, i * GridInterval, Width - 5, i * GridInterval);
for (int i = KoefLabel; i < Width / GridInterval; i += KoefLabel)
this.Chart.DrawLine(LineMark, i * GridInterval, Height - 7, i * GridInterval, Height -5);
}
//-----------------------------------------------------------------------------------------------------------
void Init(Color BackraudColor, Color PenColor)
{
this.Chart.Clear(BackraudColor);
GridLine = new Pen(PenColor, 1);
// Set the EndCap property.
GridLine.DashPattern = new float[] { 4.0F, 2.0F, 4.0F, 2.0F };
LineMark = new Pen(Color.White, 2);
LineMark.EndCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
}
}
}