Forex_Strategy_Builder.Small_Balance_Chart.OnPaint C# (CSharp) Method

OnPaint() protected method

Paints the chart
protected OnPaint ( PaintEventArgs e ) : void
e PaintEventArgs
return void
        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            // Caption bar
            Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
            g.DrawString(strChartTitle, Font, new SolidBrush(LayoutColors.ColorCaptionText), rectfCaption, stringFormatCaption);

            // Border
            g.DrawLine(penBorder, 1, captionHeight, 1, ClientSize.Height);
            g.DrawLine(penBorder, ClientSize.Width - border + 1, captionHeight, ClientSize.Width - border + 1, ClientSize.Height);
            g.DrawLine(penBorder, 0, ClientSize.Height - border + 1, ClientSize.Width, ClientSize.Height - border + 1);

            // Paints the background by gradient
            RectangleF rectField = new RectangleF(border, captionHeight, ClientSize.Width - 2 * border, ClientSize.Height - captionHeight - border);
            Data.GradientPaint(g, rectField, LayoutColors.ColorChartBack, LayoutColors.DepthControl);

            if (isNotPaint) return;

            // Grid and Price labels
            for (int label = minimum; label <= maximum; label += step)
            {
                int labelY = (int)(YBottom - (label - minimum) * YScale);
                g.DrawString(label.ToString(), Font, brushFore, XRight, labelY - Font.Height / 2 - 1);
                g.DrawLine(penGrid, XLeft, labelY, XRight, labelY);
            }

            // Price close
            if (showPriceLine)
                g.DrawLines(new Pen(LayoutColors.ColorChartGrid), apntClosePrice);

            // Equity line
            g.DrawLines(new Pen(LayoutColors.ColorChartEquityLine), apntEquity);

            // Draw Long and Short balance
            if (Configs.AdditionalStatistics)
            {
                g.DrawLines(new Pen(Color.Red),  apntShortBalance);
                g.DrawLines(new Pen(Color.Green), apntLongBalance);
            }

            // Out of Sample
            if (isOOS && barOOS > 0)
            {
                g.DrawLine(new Pen(LayoutColors.ColorChartFore), XOOSBar, YTop, XOOSBar, YBottom);
                Brush brushOOS = new Pen(LayoutColors.ColorChartFore).Brush;
                g.DrawString("OOS", Font, brushOOS, XOOSBar, YBottom - Font.Height);
                float OOSBarDateWidth = g.MeasureString(dataTimeBarOOS.ToShortDateString(), Font).Width;
                g.DrawString(dataTimeBarOOS.ToShortDateString(), Font, brushOOS, XOOSBar - OOSBarDateWidth, YBottom - Font.Height);
            }

            // In case of Margin Call
            if (marginCallBar > 0)
            {
                PointF[] apntfGreenBalance = new PointF[marginCallBar - firstBar];
                for (int i = 0; i < apntfGreenBalance.Length; i++)
                    apntfGreenBalance[i] = apntBalance[i];

                PointF[] apntfRedBalance = new PointF[bars - marginCallBar];
                for (int i = 0; i < apntfRedBalance.Length; i++)
                    apntfRedBalance[i] = apntBalance[i + marginCallBar - firstBar];

                if (apntfGreenBalance.Length > 1)
                    g.DrawLines(new Pen(LayoutColors.ColorChartBalanceLine), apntfGreenBalance);
                g.DrawLines(new Pen(LayoutColors.ColorSignalRed), apntfRedBalance);

                // Margin Call line
                g.DrawLine(new Pen(LayoutColors.ColorChartCross), XMarginCallBar, YTop, XMarginCallBar, YBottom);
                Brush brushBancrupcy = new Pen(LayoutColors.ColorChartBalanceLine).Brush;
                float fMarginCallWidht = g.MeasureString(Language.T("Margin Call"), Font).Width;
                if (XMarginCallBar < XRight - fMarginCallWidht)
                    g.DrawString(Language.T("Margin Call"), Font, brushFore, XMarginCallBar, YTop);
                else if (XMarginCallBar > space + fMarginCallWidht)
                    g.DrawString(Language.T("Margin Call"), Font, brushFore, XMarginCallBar - fMarginCallWidht, YTop);
                else
                    g.DrawString("MC", Font, brushFore, XMarginCallBar, YTop);
            }
            else
            {   // Draw the balance line
                g.DrawLines(new Pen(LayoutColors.ColorChartBalanceLine), apntBalance);
            }

            // Balance level
            g.DrawLine(new Pen(LayoutColors.ColorChartCross), XLeft, YBalance, XRight - space + 1, YBalance);

            // Scanning note
            Font fontNote = new Font(Font.FontFamily, Font.Size - 1);
            if (Data.Period != DataPeriods.min1 && Configs.Autoscan && !Data.IsIntrabarData)
                g.DrawString(Language.T("Load intrabar data"), fontNote, Brushes.Red, XLeft, captionHeight - 2);
            else if (Data.Period != DataPeriods.min1 && isScanPerformed)
                g.DrawString(Language.T("Scanned") + modellingQuolity, fontNote, Brushes.LimeGreen, XLeft, captionHeight - 2);

            // Scanned bars
            if (isScanPerformed && !isHideScanningLine &&
                (Data.IntraBars != null && Data.IsIntrabarData ||
                 Data.Period == DataPeriods.min1 && Data.IsTickData && Configs.UseTickData))
            {
                DataPeriods dataPeriod = Data.Period;
                Color color   = Data.PeriodColor[Data.Period];
                int   fromBar = firstBar;
                for (int bar = firstBar; bar < bars; bar++)
                {
                    if (Data.IntraBarsPeriods[bar] != dataPeriod || bar == bars - 1)
                    {
                        int xStart = (int)((fromBar - firstBar) * XScale) + XLeft;
                        int xEnd   = (int)((bar     - firstBar) * XScale) + XLeft;
                        fromBar = bar;
                        dataPeriod = Data.IntraBarsPeriods[bar];
                        Data.GradientPaint(g, new RectangleF(xStart, YBottom + 4, xEnd - xStart + 2, 5), color, 60);
                        color = Data.PeriodColor[Data.IntraBarsPeriods[bar]];
                    }
                }

                // Tick Data
                if (Data.IsTickData && Configs.UseTickData)
                {
                    int firstBarWithTicks = -1;
                    int lastBarWithTicks  = -1;
                    for (int b = 0; b < bars; b++)
                    {
                        if (firstBarWithTicks == -1 && Data.TickData[b] != null)
                            firstBarWithTicks = b;
                        if (Data.TickData[b] != null)
                            lastBarWithTicks = b;
                    }
                    int xStart = (int)((firstBarWithTicks - firstBar) * XScale) + XLeft;
                    int xEnd   = (int)((lastBarWithTicks  - firstBar) * XScale) + XLeft;
                    Data.GradientPaint(g, new RectangleF(xStart, YBottom + 4, xEnd - xStart + 2, 5), color, 60);

                    RectangleF rectf = new RectangleF(xStart, YBottom + 4, xEnd - xStart + 2, 5);
                    Data.GradientPaint(g, rectf, Data.PeriodColor[DataPeriods.min1], 60);
                    rectf = new RectangleF(xStart, YBottom + 6, xEnd - xStart + 2, 1);
                    Data.GradientPaint(g, rectf, Data.PeriodColor[DataPeriods.day], 60);
                }

                // Vertical coordinate axes
                g.DrawLine(new Pen(LayoutColors.ColorChartFore), XLeft - 1, YBottom, XLeft - 1, YBottom + 9);
            }

            // Coordinate axes
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), XLeft - 1, YTop - space, XLeft - 1, YBottom + 1);
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), XLeft - 1, YBottom + 1, XRight, YBottom + 1);

            // Balance label
            Size szBalance = new Size(labelWidth + space, Font.Height + 2);
            Point point = new Point(XRight - space + 2, (int)(YBalance - Font.Height / 2 - 1));
            Rectangle rec = new Rectangle(point, szBalance);
            g.FillRectangle(new SolidBrush(LayoutColors.ColorLabelBack), rec);
            g.DrawRectangle(new Pen(LayoutColors.ColorChartCross), rec);
            g.DrawString((Math.Round(balance)).ToString(), Font, new SolidBrush(LayoutColors.ColorLabelText), rec, stringFormatCaption);

            return;
        }