예제 #1
0
        private string GetPriceString(double price, ChartBars chartBars)
        {
            string priceString;
            double yValueEntry = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(EntryAnchor.Price);
            double tickSize    = AttachedTo.Instrument.MasterInstrument.TickSize;
            double pointValue  = AttachedTo.Instrument.MasterInstrument.PointValue;

            switch (DisplayUnit)
            {
            case ValueUnit.Currency:
                if (AttachedTo.Instrument.MasterInstrument.InstrumentType == InstrumentType.Forex)
                {
                    priceString = price > yValueEntry?
                                  Core.Globals.FormatCurrency(AttachedTo.Instrument.MasterInstrument.RoundToTickSize(price - yValueEntry) / tickSize *(tickSize * pointValue * Account.All[0].ForexLotSize)) :
                                      Core.Globals.FormatCurrency(AttachedTo.Instrument.MasterInstrument.RoundToTickSize(yValueEntry - price) / tickSize * (tickSize * pointValue * Account.All[0].ForexLotSize));
                }
                else
                {
                    priceString = price > yValueEntry?
                                  Core.Globals.FormatCurrency(AttachedTo.Instrument.MasterInstrument.RoundToTickSize(price - yValueEntry) / tickSize *(tickSize *pointValue)) :
                                      Core.Globals.FormatCurrency(AttachedTo.Instrument.MasterInstrument.RoundToTickSize(yValueEntry - price) / tickSize * (tickSize * pointValue));
                }
                break;

            case ValueUnit.Percent:
                priceString = price > yValueEntry ?
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(price - yValueEntry) / yValueEntry).ToString("P", Core.Globals.GeneralOptions.CurrentCulture) :
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(yValueEntry - price) / yValueEntry).ToString("P", Core.Globals.GeneralOptions.CurrentCulture);
                break;

            case ValueUnit.Ticks:
                priceString = price > yValueEntry ?
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(price - yValueEntry) / tickSize).ToString("F0") :
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(yValueEntry - price) / tickSize).ToString("F0");
                break;

            case ValueUnit.Pips:
                priceString = price > yValueEntry ?
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(price - yValueEntry) / tickSize / 10).ToString("F0") :
                              (AttachedTo.Instrument.MasterInstrument.RoundToTickSize(yValueEntry - price) / tickSize / 10).ToString("F0");
                break;

            default:
                priceString = chartBars.Bars.Instrument.MasterInstrument.FormatPrice(price);
                break;
            }
            return(priceString);
        }
예제 #2
0
        // TODO:  Disabled for now, need sure recntangels are drawn historically and for all price zones
        private void RenderPriceZoneAreas(ChartControl chartControl, ChartScale chartScale, int barIndex, int plotIndex)
        {
            SharpDX.RectangleF rectangleF = new SharpDX.RectangleF();

            DateTime tm = ChartBars.GetTimeByBarIdx(chartControl, barIndex).Date;

            PriceZone zone = zonesList[tm];


            rectangleF.Top    = chartScale.GetYByValue(zone.ZoneStrong);
            rectangleF.Bottom = chartScale.GetYByValue(zone.ZoneWeak);
            rectangleF.Left   = chartControl.GetXByTime(zone.StartTime);
            rectangleF.Right  = ChartControl.GetXByTime(zone.EndTime);

            Brush tmpBrush = Plots[plotIndex].Brush.Clone();

            tmpBrush.Opacity = .05;
            tmpBrush.Freeze();
            RenderTarget.FillRectangle(rectangleF, tmpBrush.ToDxBrush(RenderTarget));
        }
예제 #3
0
        private ChartBars GetChartBars()
        {
            if (AttachedTo != null)
            {
                ChartBars chartBars = AttachedTo.ChartObject as ChartBars;
                if (chartBars == null)
                {
                    Gui.NinjaScript.IChartBars iChartBars = AttachedTo.ChartObject as Gui.NinjaScript.IChartBars;
                    if (iChartBars != null)
                    {
                        chartBars = iChartBars.ChartBars;
                    }
                }

                if (chartBars != null)
                {
                    return(chartBars);
                }
            }

            return(null);
        }
        public void init_or_deinit(object indi_or_strat_, bool init)
        {
            log("init_or_deinit1");
            if (init && indi_or_strat == null)
            {
                // for generic purposes
                indi_or_strat = (NinjaTrader.NinjaScript.NinjaScriptBase)indi_or_strat_;

                if (indi_or_strat_ is NinjaTrader.NinjaScript.Indicators.Indicator)
                {
                    indi         = (NinjaTrader.NinjaScript.Indicators.Indicator)indi_or_strat_;
                    chartControl = indi.ChartControl;
                    chartPnl     = indi.ChartControl.ChartPanels[0];
                    chartBars    = indi.ChartBars;
                }
                else if (indi_or_strat_ is NinjaTrader.NinjaScript.Strategies.Strategy)
                {
                    strat        = (NinjaTrader.NinjaScript.Strategies.Strategy)indi_or_strat_;
                    chartControl = strat.ChartControl;
                    chartPnl     = strat.ChartControl.ChartPanels[0];
                    chartBars    = strat.ChartBars;
                }

                if (chartControl == null || chartPnl == null)
                {
                    enabled = false; return;
                }

                enabled = true;
                registerEventHandlers();
            }
            else
            {
                checkForDeregister();
            }
            log("init_or_deinit2");
        }
예제 #5
0
        protected override Point[] OnGetSelectionPoints(ChartControl chartControl, ChartScale chartScale)
        {
            if (!IsSelected || Count == 0 || Plots[0].Brush.IsTransparent() || startIndex == int.MinValue)
            {
                return(new System.Windows.Point[0]);
            }

            List <System.Windows.Point> points = new List <System.Windows.Point>();

            int lastIndex = Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? ChartBars.ToIndex - 1 : ChartBars.ToIndex - 2;

            for (int i = Math.Max(0, ChartBars.FromIndex - Displacement); i <= Math.Max(lastIndex, Math.Min(Bars.Count - (Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? 2 : 1), lastIndex - Displacement)); i++)
            {
                int x = (chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && i + Displacement >= ChartBars.Count
                                        ? chartControl.GetXByTime(ChartBars.GetTimeByBarIdx(chartControl, i + Displacement))
                                        : chartControl.GetXByBarIndex(ChartBars, i + Displacement));

                if (Value.IsValidDataPointAt(i))
                {
                    points.Add(new System.Windows.Point(x, chartScale.GetYByValue(Value.GetValueAt(i))));
                }
            }
            return(points.ToArray());
        }
예제 #6
0
        // drawZones
        //
        private void drawZones(ChartControl chartControl, ChartScale chartScale)
        {
            if (hideActiveZones && hideBrokenZones)
            {
                return;
            }
            if (Zones.Count == 0)
            {
                return;
            }

            SharpDX.Direct2D1.AntialiasMode oldAntialiasMode = RenderTarget.AntialiasMode;
            RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.Aliased;

            SharpDX.Direct2D1.Brush demandBrush = demandColor.ToDxBrush(RenderTarget);
            SharpDX.Direct2D1.Brush supplyBrush = supplyColor.ToDxBrush(RenderTarget);

            int x1 = 0;
            int x2 = 0;
            int y1 = 0;
            int y2 = 0;

            int wd = (int)(chartControl.BarWidth / 2.0) + (int)(chartControl.BarMarginLeft / 2.0);

            for (int i = 0; i < Zones.Count; i++)
            {
                if (Zones[i].a == true && hideActiveZones)
                {
                    continue;
                }
                if (Zones[i].a == false && hideBrokenZones)
                {
                    continue;
                }

                if (barIndex == 0)
                {
                    x1 = ChartControl.GetXByBarIndex(ChartBars, Zones[i].b);
                    x2 = (Zones[i].a == false) ? ChartControl.GetXByBarIndex(ChartBars, Zones[i].e) : (int)(ChartControl.GetXByBarIndex(ChartBars, ChartBars.ToIndex) + wd);
                    x2 = (Zones[i].a == true && extendZones) ? chartControl.CanvasRight: x2;
                }
                else
                {
                    x1 = ChartControl.GetXByBarIndex(ChartBars, findBar(Zones[i]));
                    //x1 = ChartControl.GetXByBarIndex(ChartBars, BarsArray[0].GetBar(BarsArray[1].GetTime(Zones[i].b)));
                    x2 = (Zones[i].a == false) ? ChartControl.GetXByBarIndex(ChartBars, ChartBars.GetBarIdxByTime(chartControl, BarsArray[1].GetTime(Zones[i].e))) : (int)(ChartControl.GetXByBarIndex(ChartBars, ChartBars.ToIndex) + wd);
                    x2 = (Zones[i].a == true && extendZones) ? chartControl.CanvasRight: x2;
                }

                if (x2 < x1)
                {
                    continue;
                }

                y1 = chartScale.GetYByValue(Zones[i].h);
                y2 = chartScale.GetYByValue(Zones[i].l);

                // area

                SharpDX.RectangleF rect = new SharpDX.RectangleF();

                rect.X      = (float)x1;
                rect.Y      = (float)y1;
                rect.Width  = (float)Math.Abs(x2 - x1);
                rect.Height = (float)Math.Abs(y1 - y2) - 1;

                if (Zones[i].a == true)
                {
                    demandBrush.Opacity = activeAreaOpacity;
                    supplyBrush.Opacity = activeAreaOpacity;
                }
                else
                {
                    demandBrush.Opacity = brokenAreaOpacity;
                    supplyBrush.Opacity = brokenAreaOpacity;
                }

                if (Zones[i].t == "d")
                {
                    RenderTarget.FillRectangle(rect, demandBrush);
                }

                if (Zones[i].t == "s")
                {
                    RenderTarget.FillRectangle(rect, supplyBrush);
                }

                // line one

                if (Zones[i].a == true)
                {
                    demandBrush.Opacity = activeLineOpacity;
                    supplyBrush.Opacity = activeLineOpacity;
                }
                else
                {
                    demandBrush.Opacity = brokenLineOpacity;
                    supplyBrush.Opacity = brokenLineOpacity;
                }

                SharpDX.Vector2 pOne = new SharpDX.Vector2();
                SharpDX.Vector2 pTwo = new SharpDX.Vector2();

                pOne.X = (float)x1;
                pOne.Y = (float)y1;
                pTwo.X = (float)x2;
                pTwo.Y = (float)y1;

                if (Zones[i].t == "d")
                {
                    RenderTarget.DrawLine(pOne, pTwo, demandBrush, lineWidth);
                }

                if (Zones[i].t == "s")
                {
                    RenderTarget.DrawLine(pOne, pTwo, supplyBrush, lineWidth);
                }

                // line two

                pOne.X = (float)x1;
                pOne.Y = (float)y2;
                pTwo.X = (float)x2;
                pTwo.Y = (float)y2;

                if (Zones[i].t == "d")
                {
                    RenderTarget.DrawLine(pOne, pTwo, demandBrush, lineWidth);
                }

                if (Zones[i].t == "s")
                {
                    RenderTarget.DrawLine(pOne, pTwo, supplyBrush, lineWidth);
                }
            }

            RenderTarget.AntialiasMode = oldAntialiasMode;

            // ---

            demandBrush.Dispose();
            supplyBrush.Dispose();
        }
예제 #7
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            if (chartBars.FromIndex > chartBars.ToIndex)
            {
                return;
            }

            if (chartBars.FromIndex > 0)
            {
                chartBars.FromIndex--;
            }

            Bars    bars              = chartBars.Bars;
            float   barWidth          = GetBarPaintWidth(BarWidthUI);
            int     sessionStartIndex = chartBars.FromIndex;
            int     thickOffsetTop    = (int)(Stroke.Width * 0.5);
            int     thinOffsetTop     = (int)(Stroke2.Width * 0.5);
            Vector2 point0            = new Vector2();
            Vector2 point1            = new Vector2();

            while (sessionStartIndex > 0 && bars.BarsType.IsIntraday)
            {
                if (bars.BarsSeries.GetIsFirstBarOfSession(sessionStartIndex))
                {
                    break;
                }
                sessionStartIndex--;
            }

            if (sessionStartIndex < 0)             // Occurs when all bars are off screen
            {
                return;
            }

            thickLine = bars.GetClose(sessionStartIndex) > bars.GetOpen(sessionStartIndex);

            //Determine the next bar coming up is thick or thin
            for (int k = sessionStartIndex + 1; k < chartBars.FromIndex; k++)
            {
                double closeTest = bars.GetClose(k);
                if (closeTest > bars.GetOpen(k))
                {
                    if (Math.Max(bars.GetOpen(k - 1), bars.GetClose(k - 1)) < closeTest)
                    {
                        thickLine = true;
                    }
                }
                else if (closeTest < Math.Min(bars.GetOpen(k - 1), bars.GetClose(k - 1)))
                {
                    thickLine = false;
                }
            }

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                Brush  overriddenBrush = chartControl.GetBarOverrideBrush(chartBars, idx);
                double openValue       = bars.GetOpen(idx);
                float  open            = chartScale.GetYByValue(openValue);
                double closeValue      = bars.GetClose(idx);
                float  close           = chartScale.GetYByValue(closeValue);
                float  x              = chartControl.GetXByBarIndex(chartBars, idx);
                double prevOpenValue  = idx == 0 ? openValue : bars.GetOpen(idx - 1);
                double prevCloseValue = idx == 0 ? closeValue : bars.GetClose(idx - 1);

                float startPosition;
                if (idx == 0 && chartBars.ToIndex >= 1)
                {
                    float x0    = chartControl.GetXByBarIndex(chartBars, 0);
                    float x1    = chartControl.GetXByBarIndex(chartBars, 1);
                    float diffX = Math.Max(1, x1 - x0);
                    startPosition = x0 - diffX;
                }
                else
                {
                    startPosition = idx == chartBars.FromIndex ? chartControl.GetXByBarIndex(chartBars, idx) : chartControl.GetXByBarIndex(chartBars, idx - 1);
                }

                startPosition = startPosition < 0 ? 0 : startPosition;

                if (bars.BarsType.IsIntraday && bars.IsResetOnNewTradingDay && bars.BarsSeries.GetIsFirstBarOfSession(idx))
                {
                    // First bar
                    if (closeValue > openValue)
                    {
                        point0.X = x;
                        point0.Y = open;
                        point1.X = x;
                        point1.Y = close;
                        TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                        RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                        thickLine = true;
                    }
                    else
                    {
                        point0.X = x;
                        point0.Y = open;
                        point1.X = x;
                        point1.Y = close;
                        TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                        RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                        thickLine = false;
                    }
                }
                else
                {
                    if (closeValue > openValue)
                    {
                        if (closeValue <= Math.Max(prevCloseValue, prevOpenValue))
                        {
                            // Maintain previous thickness
                            if (thickLine)
                            {
                                point0.X = x;
                                point0.Y = open + thickOffsetTop;
                                point1.X = x;
                                point1.Y = close - thickOffsetTop;
                                TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                                point0.X = startPosition;
                                point0.Y = open;
                                point1.X = x;
                                point1.Y = open;
                                TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                            }
                            else
                            {
                                point0.X = x;
                                point0.Y = open + thinOffsetTop;
                                point1.X = x;
                                point1.Y = close - thinOffsetTop;
                                TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                                point0.X = startPosition;
                                point0.Y = open;
                                point1.X = x;
                                point1.Y = open;
                                TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                            }
                        }
                        else if (closeValue > Math.Max(prevCloseValue, prevOpenValue))
                        {
                            double transitionPoint = Math.Max(prevCloseValue, prevOpenValue);

                            point0.X = x;
                            point0.Y = close - thickOffsetTop;
                            point1.X = x;
                            point1.Y = chartScale.GetYByValue(transitionPoint);
                            TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                            RenderTarget.DrawLine(point0, point1, Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                            point0.X = x;
                            point0.Y = chartScale.GetYByValue(transitionPoint);
                            point1.X = x;
                            point1.Y = open + (thickLine ? thickOffsetTop : thinOffsetTop);
                            TransformBrush(overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), new RectangleF(point0.X, point0.Y - (thickLine ? Stroke.Width : Stroke2.Width), barWidth, thickLine ? Stroke.Width : Stroke2.Width));
                            RenderTarget.DrawLine(point0, point1, overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), thickLine ? Stroke.Width : Stroke2.Width, thickLine ? Stroke.StrokeStyle : Stroke2.StrokeStyle);
                            point0.X = startPosition;
                            point0.Y = open;
                            point1.X = x;
                            point1.Y = open;
                            TransformBrush(overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), new RectangleF(point0.X, point0.Y - (thickLine ? Stroke.Width : Stroke2.Width), barWidth, thickLine ? Stroke.Width : Stroke2.Width));
                            RenderTarget.DrawLine(point0, point1, overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), thickLine ? Stroke.Width : Stroke2.Width, thickLine ? Stroke.StrokeStyle : Stroke2.StrokeStyle);

                            thickLine = true;
                        }
                    }
                    else
                    {
                        if (Math.Min(prevCloseValue, prevOpenValue) <= closeValue)
                        {
                            // Maintain previous thickness
                            if (thickLine)
                            {
                                point0.X = x;
                                point0.Y = open - thickOffsetTop;
                                point1.X = x;
                                point1.Y = close + thickOffsetTop;
                                TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                                point0.X = startPosition;
                                point0.Y = open;
                                point1.X = x;
                                point1.Y = open;
                                TransformBrush(overriddenBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                            }
                            else
                            {
                                point0.X = x;
                                point0.Y = open - thinOffsetTop;
                                point1.X = x;
                                point1.Y = close + thinOffsetTop;
                                TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                                point0.X = startPosition;
                                point0.Y = open;
                                point1.X = x;
                                point1.Y = open;
                                TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                                RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                            }
                        }
                        else if (closeValue < Math.Min(prevCloseValue, prevOpenValue))
                        {
                            double transitionPoint = Math.Min(prevCloseValue, prevOpenValue);

                            point0.X = startPosition;
                            point0.Y = open;
                            point1.X = x;
                            point1.Y = open;
                            TransformBrush(overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), new RectangleF(point0.X, point0.Y - (thickLine ? Stroke.Width : Stroke2.Width), barWidth, thickLine ? Stroke.Width : Stroke2.Width));
                            RenderTarget.DrawLine(point0, point1, overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), thickLine ? Stroke.Width : Stroke2.Width, thickLine ? Stroke.StrokeStyle : Stroke2.StrokeStyle);
                            point0.X = x;
                            point0.Y = open - (thickLine ? thickOffsetTop : thinOffsetTop);
                            point1.X = x;
                            point1.Y = chartScale.GetYByValue(transitionPoint);
                            TransformBrush(overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), new RectangleF(point0.X, point0.Y - (thickLine ? Stroke.Width : Stroke2.Width), barWidth, thickLine ? Stroke.Width : Stroke2.Width));
                            RenderTarget.DrawLine(point0, point1, overriddenBrush ?? (thickLine ? Stroke.BrushDX : Stroke2.BrushDX), thickLine ? Stroke.Width : Stroke2.Width, thickLine ? Stroke.StrokeStyle : Stroke2.StrokeStyle);
                            point0.X = x;
                            point0.Y = chartScale.GetYByValue(transitionPoint);
                            point1.X = x;
                            point1.Y = close + thinOffsetTop;
                            TransformBrush(overriddenBrush ?? Stroke2.BrushDX, new RectangleF(point0.X, point0.Y - Stroke2.Width, barWidth, Stroke2.Width));
                            RenderTarget.DrawLine(point0, point1, overriddenBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);

                            thickLine = false;
                        }
                    }
                }
            }
        }
예제 #8
0
        protected override void OnBarUpdate()
        {
            if (CurrentBar < 0)
            {
                return;
            }

            // High Trend Line
            int swingHighBar = swing.SwingHighBar(0, 1, Strength + 1);

            if (swingHighBar != -1)
            {
                double swingHighPrice = !(Input is PriceSeries || Input is Bars) ? Input[swingHighBar] : High[swingHighBar];

                if (swingHighPrice < lastHighPrice && lastHighBar > -1)
                {
                    highTrend = new TrendRay(lastHighBar, lastHighPrice, CurrentBar - swingHighBar, swingHighPrice)
                    {
                        IsHigh = true
                    };
                    trendLines.Enqueue(highTrend);
                    highTrendIsActive = true;
                    alertIsArmed      = true;
                }

                lastHighBar   = CurrentBar - swingHighBar;
                lastHighPrice = swingHighPrice;
            }

            // Low Trend Line
            int swingLowBar = swing.SwingLowBar(0, 1, Strength + 1);

            if (swingLowBar != -1)
            {
                double swingLowPrice = !(Input is PriceSeries || Input is Bars) ? Input[swingLowBar] : Low[swingLowBar];

                if (swingLowPrice > lastLowPrice && lastLowBar > -1)
                {
                    lowTrend = new TrendRay(lastLowBar, lastLowPrice, CurrentBar - swingLowBar, swingLowPrice);
                    trendLines.Enqueue(lowTrend);
                    highTrendIsActive = false;
                    alertIsArmed      = true;
                }

                lastLowBar   = CurrentBar - swingLowBar;
                lastLowPrice = swingLowPrice;
            }

            if (highTrendIsActive.HasValue)
            {
                if (ChartControl == null || ChartControl.BarSpacingType == BarSpacingType.TimeBased)
                {
                    if (highTrendIsActive.Value)
                    {
                        double slope = (highTrend.EndPrice - highTrend.StartPrice) / (highTrend.EndBar - highTrend.StartBar);
                        Values[0][0] = slope * CurrentBar - (slope * highTrend.StartBar - highTrend.StartPrice);
                    }
                    else
                    {
                        double slope = (lowTrend.EndPrice - lowTrend.StartPrice) / (lowTrend.EndBar - lowTrend.StartBar);
                        Values[0][0] = slope * CurrentBar - (slope * lowTrend.StartBar - lowTrend.StartPrice);
                    }
                }
                else
                {
                    if (highTrendIsActive.Value)
                    {
                        double startSlotIndex = ChartControl.GetSlotIndexByTime(ChartBars.GetTimeByBarIdx(ChartControl, highTrend.StartBar));
                        double endSlotIndex   = ChartControl.GetSlotIndexByTime(ChartBars.GetTimeByBarIdx(ChartControl, highTrend.EndBar));
                        double curSlotIndex   = ChartControl.GetSlotIndexByTime(Time[0]);
                        double slope          = (highTrend.EndPrice - highTrend.StartPrice) / (endSlotIndex - startSlotIndex);
                        Values[0][0] = slope * curSlotIndex - (slope * startSlotIndex - highTrend.StartPrice);
                    }
                    else
                    {
                        double startSlotIndex = ChartControl.GetSlotIndexByTime(ChartBars.GetTimeByBarIdx(ChartControl, lowTrend.StartBar));
                        double endSlotIndex   = ChartControl.GetSlotIndexByTime(ChartBars.GetTimeByBarIdx(ChartControl, lowTrend.EndBar));
                        double curSlotIndex   = ChartControl.GetSlotIndexByTime(Time[0]);
                        double slope          = (lowTrend.EndPrice - lowTrend.StartPrice) / (endSlotIndex - startSlotIndex);
                        Values[0][0] = slope * curSlotIndex - (slope * startSlotIndex - lowTrend.StartPrice);
                    }
                }

                if (State == State.Realtime && AlertOnBreak && alertIsArmed)
                {
                    if (CrossAbove(Input, Values[0][0], 1) || CrossBelow(Input, Values[0][0], 1))
                    {
                        Alert(string.Empty, Priority.High, string.Format(NinjaTrader.Custom.Resource.TrendLinesTrendLineBroken,
                                                                         highTrendIsActive.Value ? NinjaTrader.Custom.Resource.TrendLinesTrendLineHigh: NinjaTrader.Custom.Resource.TrendLinesTrendLineLow),
                              AlertOnBreakSound, 0, Brushes.Transparent, highTrendIsActive.Value ? TrendLineHighStroke.Brush : TrendLineLowStroke.Brush);

                        alertIsArmed = false;
                    }
                }
            }
        }
예제 #9
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            double boxHeightActual = Math.Floor(10000000.0 * chartBars.Bars.BarsPeriod.Value * chartBars.Bars.Instrument.MasterInstrument.TickSize) / 10000000.0;
            int    boxSize         = (int)Math.Round(chartScale.Height.ConvertToVerticalPixels(chartControl.PresentationSource) / Math.Round(chartScale.MaxMinusMin / boxHeightActual, 0));

            AntialiasMode oldAliasMode = RenderTarget.AntialiasMode;

            RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
            trendDetermined            = false;

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                int    barWidth = GetBarPaintWidth(BarWidthUI);
                double closeVal = chartBars.Bars.GetClose(idx);
                double openVal  = chartBars.Bars.GetOpen(idx);

                int   boxDrawCount = openVal == closeVal ? 1 : (int)Math.Round(Math.Abs(openVal - closeVal) / boxHeightActual, 0) + 1;
                float close        = chartScale.GetYByValue(closeVal);
                float open         = chartScale.GetYByValue(openVal);

                float nextBox = Math.Min(open, close);
                float x       = chartControl.GetXByBarIndex(chartBars, idx);

                float diff = Math.Abs(open - close) + boxSize - (int)Math.Round((double)(boxSize * boxDrawCount));

                if (closeVal == openVal)
                {
                    if (idx == 0)
                    {
                        RenderTarget.DrawRectangle(new RectangleF(x - barWidth / 2.0f + 1, nextBox - boxSize / 2.0f + 2, barWidth - 1, boxSize - 2), DownBrushDX, Stroke.Width);
                        Vector2 point0;
                        Vector2 point1;

                        point0.X = x - barWidth / 2.0f;
                        point0.Y = nextBox - boxSize / 2.0f;
                        point1.X = x + barWidth / 2.0f;
                        point1.Y = nextBox + boxSize - boxSize / 2.0f;
                        if (!(UpBrushDX is SharpDX.Direct2D1.SolidColorBrush))
                        {
                            TransformBrush(UpBrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                        }
                        RenderTarget.DrawLine(point0, point1, UpBrushDX, Stroke.Width, Stroke.StrokeStyle);

                        point0.X = x - barWidth / 2.0f;
                        point0.Y = nextBox + boxSize - boxSize / 2.0f;
                        point1.X = x + barWidth / 2.0f;
                        point1.Y = nextBox - boxSize / 2.0f;
                        if (!(UpBrushDX is SharpDX.Direct2D1.SolidColorBrush))
                        {
                            TransformBrush(UpBrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                        }
                        RenderTarget.DrawLine(point0, point1, UpBrushDX, Stroke.Width, Stroke.StrokeStyle);

                        continue;
                    }

                    if (!trendDetermined)
                    {
                        if (chartBars.Bars.GetOpen(idx - 1) == chartBars.Bars.GetClose(idx - 1))
                        {
                            if (chartBars.Bars.GetHigh(idx) < chartBars.Bars.GetHigh(idx - 1))
                            {
                                isUp = false;
                            }
                        }
                        else
                        {
                            isUp = !(chartBars.Bars.GetOpen(idx - 1) < chartBars.Bars.GetClose(idx - 1));
                        }

                        trendDetermined = true;
                    }
                    else
                    {
                        isUp = !isUp;
                    }
                }
                else
                {
                    isUp = closeVal > openVal;
                }

                for (int k = 0; k < boxDrawCount; k++)
                {
                    if (diff != 0)
                    {
                        nextBox += diff > 0 ? 1 : -1;
                        diff    += diff > 0 ? -1 : 1;
                    }

                    if (!isUp)
                    {
                        Ellipse ellipse;
                        ellipse.Point   = new Vector2(x, nextBox);
                        ellipse.RadiusX = barWidth / 2.0f;
                        ellipse.RadiusY = boxSize / 2.0f - 1;
                        if (!(DownBrushDX is SharpDX.Direct2D1.SolidColorBrush))
                        {
                            TransformBrush(DownBrushDX, new RectangleF(ellipse.Point.X - ellipse.RadiusX, ellipse.Point.Y - ellipse.RadiusY - Stroke.Width, barWidth, Stroke.Width));
                        }
                        RenderTarget.DrawEllipse(ellipse, DownBrushDX, Stroke.Width);
                    }
                    else
                    {
                        Vector2 point0;
                        Vector2 point1;

                        point0.X = x - barWidth / 2.0f;
                        point0.Y = nextBox - boxSize / 2.0f;
                        point1.X = x + barWidth / 2.0f;
                        point1.Y = nextBox + boxSize - boxSize / 2.0f;
                        if (!(UpBrushDX is SharpDX.Direct2D1.SolidColorBrush))
                        {
                            TransformBrush(UpBrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                        }
                        RenderTarget.DrawLine(point0, point1, UpBrushDX, Stroke.Width, Stroke.StrokeStyle);

                        point0.X = x - barWidth / 2.0f;
                        point0.Y = nextBox + boxSize - boxSize / 2.0f;
                        point1.X = x + barWidth / 2.0f;
                        point1.Y = nextBox - boxSize / 2.0f;
                        if (!(UpBrushDX is SharpDX.Direct2D1.SolidColorBrush))
                        {
                            TransformBrush(UpBrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                        }
                        RenderTarget.DrawLine(point0, point1, UpBrushDX, Stroke.Width, Stroke.StrokeStyle);
                    }

                    nextBox += boxSize;
                }
            }
            RenderTarget.AntialiasMode = oldAliasMode;
        }
예제 #10
0
        protected override void OnRender(Gui.Chart.ChartControl chartControl, Gui.Chart.ChartScale chartScale)
        {
            if (Bars == null || chartControl == null || startIndex == int.MinValue)
            {
                return;
            }

            IsValidDataPointAt(Bars.Count - 1 - (Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? 1 : 0));             // Make sure indicator is calculated until last (existing) bar
            int preDiff = 1;

            for (int i = ChartBars.FromIndex - 1; i >= 0; i--)
            {
                if (i - Displacement < startIndex || i - Displacement > Bars.Count - 1 - (Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? 1 : 0))
                {
                    break;
                }

                bool isHigh = zigZagHighZigZags.IsValidDataPointAt(i - Displacement);
                bool isLow  = zigZagLowZigZags.IsValidDataPointAt(i - Displacement);

                if (isHigh || isLow)
                {
                    break;
                }

                preDiff++;
            }

            preDiff -= (Displacement < 0 ? Displacement : 0 - Displacement);

            int postDiff = 0;

            for (int i = ChartBars.ToIndex; i <= zigZagHighZigZags.Count; i++)
            {
                if (i - Displacement < startIndex || i - Displacement > Bars.Count - 1 - (Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? 1 : 0))
                {
                    break;
                }

                bool isHigh = zigZagHighZigZags.IsValidDataPointAt(i - Displacement);
                bool isLow  = zigZagLowZigZags.IsValidDataPointAt(i - Displacement);

                if (isHigh || isLow)
                {
                    break;
                }

                postDiff++;
            }

            postDiff += (Displacement < 0 ? 0 - Displacement : Displacement);

            int    lastIdx   = -1;
            double lastValue = -1;

            SharpDX.Direct2D1.PathGeometry g    = null;
            SharpDX.Direct2D1.GeometrySink sink = null;

            for (int idx = ChartBars.FromIndex - preDiff; idx <= ChartBars.ToIndex + postDiff; idx++)
            {
                if (idx < startIndex || idx > Bars.Count - (Calculate == NinjaTrader.NinjaScript.Calculate.OnBarClose ? 2 : 1) || idx < Math.Max(BarsRequiredToPlot - Displacement, Displacement))
                {
                    continue;
                }

                bool isHigh = zigZagHighZigZags.IsValidDataPointAt(idx);
                bool isLow  = zigZagLowZigZags.IsValidDataPointAt(idx);

                if (!isHigh && !isLow)
                {
                    continue;
                }

                double value = isHigh ? zigZagHighZigZags.GetValueAt(idx) : zigZagLowZigZags.GetValueAt(idx);

                if (lastIdx >= startIndex)
                {
                    float x1 = (chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && idx + Displacement >= ChartBars.Count
                                                ? chartControl.GetXByTime(ChartBars.GetTimeByBarIdx(chartControl, idx + Displacement))
                                                : chartControl.GetXByBarIndex(ChartBars, idx + Displacement));
                    float y1 = chartScale.GetYByValue(value);

                    if (sink == null)
                    {
                        float x0 = (chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && lastIdx + Displacement >= ChartBars.Count
                                                ? chartControl.GetXByTime(ChartBars.GetTimeByBarIdx(chartControl, lastIdx + Displacement))
                                                : chartControl.GetXByBarIndex(ChartBars, lastIdx + Displacement));
                        float y0 = chartScale.GetYByValue(lastValue);
                        g    = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
                        sink = g.Open();
                        sink.BeginFigure(new SharpDX.Vector2(x0, y0), SharpDX.Direct2D1.FigureBegin.Hollow);
                    }
                    sink.AddLine(new SharpDX.Vector2(x1, y1));
                }

                // Save as previous point
                lastIdx   = idx;
                lastValue = value;
            }

            if (sink != null)
            {
                sink.EndFigure(SharpDX.Direct2D1.FigureEnd.Open);
                sink.Close();
            }

            if (g != null)
            {
                var oldAntiAliasMode = RenderTarget.AntialiasMode;
                RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;
                RenderTarget.DrawGeometry(g, Plots[0].BrushDX, Plots[0].Width, Plots[0].StrokeStyle);
                RenderTarget.AntialiasMode = oldAntiAliasMode;
                g.Dispose();
                RemoveDrawObject("NinjaScriptInfo");
            }
            else
            {
                Draw.TextFixed(this, "NinjaScriptInfo", NinjaTrader.Custom.Resource.ZigZagDeviationValueError, TextPosition.BottomRight);
            }
        }
예제 #11
0
        protected override void OnBarUpdate()
        {
            // Get time of first bar on chart
            if (isFirstChartBar)
            {
                isFirstChartBar = false;
                chartStartTime  = Time[0];
            }

            // Not Enough History to calc rel vol
            if (Time[0].Date.AddDays(LookBackDays * -1) < chartStartTime.Date)
            {
                return;
            }

            // Only gather vol history on first tick
            // of bar since history does not change for
            // a given bar
            if (IsFirstTickOfBar)
            {
                int skipDays = 0;
                totalHistPeriodVol = 0;
                histPeriodVol      = new List <double>(LookBackDays);

                // Loop until all same timeperiod lookback days
                // are found or lookback exceeds history
                while (histPeriodVol.Count < LookBackDays)
                {
                    // Bar target time
                    DateTime tt = Time[0].AddDays((histPeriodVol.Count + 1 + skipDays) * -1);

                    // Bail if target day is before first chart, not enough history
                    if (tt.Date < Time[CurrentBar].Date)
                    {
                        return;
                    }

                    // No weekends
                    if ((tt.DayOfWeek == DayOfWeek.Saturday) || (tt.DayOfWeek == DayOfWeek.Sunday))
                    {
                        skipDays++;
                        continue;
                    }

                    // Skip over early close days and Holidays
                    if (TradingHours.PartialHolidays.ContainsKey(tt.Date) ||
                        TradingHours.Holidays.ContainsKey(tt.Date))
                    {
                        skipDays++;
                        continue;
                    }

                    // Get Prev day's same time bar
                    int relPrevBar = ChartBars.GetBarIdxByTime(ChartControl, tt);

                    // If the returned bar is not the expected date, a bar with the
                    // timetarget is not on the chart.  Dont know why GetBarIdxByTime
                    // does not return something more normal(like a -1) for a GetBarIdxXXX()
                    // miss.  Instead it just returns the incorrect bar.
                    // At this point a missing bar is unexpected
                    if (tt != Bars.GetTime(relPrevBar))
                    {
                        throw new Exception("Missing data error - Target Time: " + tt + " Found Time: " + Bars.GetTime(relPrevBar));
                    }

                    totalHistPeriodVol += Bars.GetVolume(relPrevBar);
                    histPeriodVol.Add(Bars.GetVolume(relPrevBar));
                }
                histPeriodVolStd = this.getStandardDeviation(histPeriodVol);
                avgHistPeriodVol = totalHistPeriodVol / LookBackDays;
            }

            // Get historical average at time volume from last x days
            Values[3][0] = avgHistPeriodVol;

            // Difference between avg period vol and current bars vol
            double rel_vol_diff = Volume[0] - avgHistPeriodVol;

            // Std Hi-Low Hash marks
            Values[1][0] = Math.Max(0.0, avgHistPeriodVol - histPeriodVolStd);
            Values[2][0] = avgHistPeriodVol + histPeriodVolStd;

            // Raw period volume bars, color code based on
            // volume above, below or within 1 std band
            Values[0][0] = Volume[0];
            if (ShowVolumeBars)
            {
                // Greater than one std
                if (Volume[0] > Values[2][0])
                {
                    PlotBrushes[0][0] = VolAboveStdBrush;
                }
                // Within one std
                else if (Values[0][0] > Values[1][0])
                {
                    PlotBrushes[0][0] = VolWithinStdBrush;
                }
                // Less than 1 std
                else
                {
                    PlotBrushes[0][0] = VolBelowStdBrush;
                }
            }
            else
            {
                PlotBrushes[0][0] = Brushes.Transparent;
            }
        }
예제 #12
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars       bars     = chartBars.Bars;
            float      barWidth = GetBarPaintWidth(BarWidthUI);
            RectangleF rect     = new RectangleF();


            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                Brush  overriddenBrush        = chartControl.GetBarOverrideBrush(chartBars, idx);
                Brush  overriddenOutlineBrush = chartControl.GetCandleOutlineOverrideBrush(chartBars, idx);
                double closeValue             = bars.GetClose(idx);
                float  close     = chartScale.GetYByValue(closeValue);
                double openValue = bars.GetOpen(idx);
                float  open      = chartScale.GetYByValue(openValue);
                float  x         = chartControl.GetXByBarIndex(chartBars, idx);

                Gui.Stroke outlineStroke = closeValue >= openValue ? Stroke              : Stroke2;

                rect.X      = x - barWidth * 0.5f + 0.5f;
                rect.Y      = Math.Min(open, close);
                rect.Width  = barWidth - 1;
                rect.Height = Math.Max(open, close) - Math.Min(open, close);

                Brush b = overriddenBrush ?? (closeValue >= openValue ? UpBrushDX : DownBrushDX);
                if (!(b is SolidColorBrush))
                {
                    TransformBrush(b, rect);
                }
                RenderTarget.FillRectangle(rect, b);

                b = overriddenBrush ?? outlineStroke.BrushDX;
                if (!(b is SolidColorBrush))
                {
                    TransformBrush(b, rect);
                }
                RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? outlineStroke.BrushDX, outlineStroke.Width, outlineStroke.StrokeStyle);
            }
        }
예제 #13
0
파일: BoxStyle.cs 프로젝트: theprofe8/nt8
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars       bars      = chartBars.Bars;
            float      chartMinX = ConvertToHorizontalPixels(chartControl, chartControl.CanvasLeft + chartControl.Properties.BarMarginRight);
            RectangleF rect      = new RectangleF();
            int        toIndex   = chartBars.ToIndex;

            if (toIndex >= 0 && toIndex < bars.Count - 1)
            {
                toIndex++;
            }

            for (int idx = chartBars.FromIndex; idx <= toIndex; idx++)
            {
                double closeValue             = bars.GetClose(idx);
                float  high                   = chartScale.GetYByValue(bars.GetHigh(idx));
                float  low                    = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue              = bars.GetOpen(idx);
                Brush  overriddenBarBrush     = chartControl.GetBarOverrideBrush(chartBars, idx);
                Brush  overriddenOutlineBrush = chartControl.GetCandleOutlineOverrideBrush(chartBars, idx);
                float  x = chartControl.GetXByBarIndex(chartBars, idx);
                float  boxStartPosition;

                if (idx == chartBars.FromIndex && (toIndex == 0 || idx == 0))
                {
                    if (toIndex == 0)
                    {
                        boxStartPosition = chartMinX;
                    }
                    else
                    {
                        boxStartPosition = 2 * x - chartControl.GetXByBarIndex(chartBars, idx + 1);
                    }
                }
                else
                {
                    boxStartPosition = chartControl.GetXByBarIndex(chartBars, idx - 1);
                }

                if (Math.Abs(x - boxStartPosition) < 0.2)
                {
                    continue;
                }

                float width = Math.Max(2f, Math.Abs(x - boxStartPosition));

                if (closeValue > openValue)
                {
                    width      -= Stroke.Width;
                    rect.X      = boxStartPosition;
                    rect.Y      = high;
                    rect.Width  = width;
                    rect.Height = low - high;
                    TransformBrush(overriddenBarBrush ?? UpBrushDX, rect);
                    TransformBrush(overriddenOutlineBrush ?? Stroke.BrushDX, rect);
                    RenderTarget.FillRectangle(rect, overriddenBarBrush ?? UpBrushDX);
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                }
                else
                {
                    width      -= Stroke2.Width;
                    rect.X      = boxStartPosition;
                    rect.Y      = high;
                    rect.Width  = width;
                    rect.Height = low - high;
                    TransformBrush(overriddenBarBrush ?? DownBrushDX, rect);
                    TransformBrush(overriddenOutlineBrush ?? Stroke2.BrushDX, rect);
                    RenderTarget.FillRectangle(rect, overriddenBarBrush ?? DownBrushDX);
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                }
            }
        }
예제 #14
0
파일: OhlcStyle.cs 프로젝트: theprofe8/nt8
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars    bars      = chartBars.Bars;
            float   lineWidth = (float)Math.Max(1, BarWidth);
            Vector2 point0    = new Vector2();
            Vector2 point1    = new Vector2();
            Vector2 point2    = new Vector2();
            Vector2 point3    = new Vector2();
            Vector2 point4    = new Vector2();
            Vector2 point5    = new Vector2();

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                SharpDX.Direct2D1.Brush overriddenBrush = chartControl.GetBarOverrideBrush(chartBars, idx);
                double closeValue = bars.GetClose(idx);
                float  close      = chartScale.GetYByValue(closeValue);
                float  high       = chartScale.GetYByValue(bars.GetHigh(idx));
                float  low        = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue  = bars.GetOpen(idx);
                float  open       = chartScale.GetYByValue(openValue);
                float  x          = chartControl.GetXByBarIndex(chartBars, idx);

                point0.X = point1.X = x;
                point0.Y = high - lineWidth * 0.5f;
                point1.Y = low + lineWidth * 0.5f;

                SharpDX.Direct2D1.Brush b = overriddenBrush ?? (closeValue >= openValue ? UpBrushDX : DownBrushDX);

                if (!(b is SharpDX.Direct2D1.SolidColorBrush))
                {
                    TransformBrush(b, new RectangleF(point0.X - lineWidth * 1.5f, point0.Y, lineWidth * 3, point1.Y - point0.Y));
                }

                RenderTarget.DrawLine(point0, point1, b, lineWidth);

                if (!Equals(Mode, OhlcMode.HiLo))
                {
                    point2.X = x + lineWidth * 1.5f;
                    point2.Y = close;
                    point3.X = x;
                    point3.Y = close;

                    RenderTarget.DrawLine(point2, point3, b, lineWidth);

                    if (Equals(Mode, OhlcMode.OHLC))
                    {
                        point4.X = x - lineWidth * 1.5f;
                        point4.Y = open;
                        point5.X = x;
                        point5.Y = open;

                        RenderTarget.DrawLine(point4, point5, b, lineWidth);
                    }
                }
            }
        }
예제 #15
0
        private void UpdateTextLayout(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale)
        {
            if (isTextCreated && textLayout != null && !textLayout.IsDisposed)
            {
                return;
            }

            if (textFormat != null && !textFormat.IsDisposed)
            {
                textFormat.Dispose();
            }
            if (textLayout != null && !textLayout.IsDisposed)
            {
                textLayout.Dispose();
            }

            ChartBars chartBars = GetAttachedToChartBars();

            // bars can be null while chart is initializing
            if (chartBars == null)
            {
                return;
            }

            double yDiffPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(EndAnchor.Price - StartAnchor.Price);
            double yDiffTicks = yDiffPrice / AttachedTo.Instrument.MasterInstrument.TickSize;

            switch (YValueDisplayUnit)
            {
            case ValueUnit.Price: yValueString = chartBars.Bars.Instrument.MasterInstrument.FormatPrice(yDiffPrice); break;

            case ValueUnit.Currency:
                yValueString = AttachedTo.Instrument.MasterInstrument.InstrumentType == InstrumentType.Forex
                                                ? Core.Globals.FormatCurrency((int)Math.Abs(yDiffTicks) * Account.All[0].ForexLotSize * (AttachedTo.Instrument.MasterInstrument.TickSize * AttachedTo.Instrument.MasterInstrument.PointValue))
                                                : Core.Globals.FormatCurrency((int)Math.Abs(yDiffTicks) * (AttachedTo.Instrument.MasterInstrument.TickSize * AttachedTo.Instrument.MasterInstrument.PointValue));
                break;

            case ValueUnit.Percent: yValueString = (yDiffPrice / AttachedTo.Instrument.MasterInstrument.RoundToTickSize(StartAnchor.Price)).ToString("P", Core.Globals.GeneralOptions.CurrentCulture); break;

            case ValueUnit.Ticks: yValueString = yDiffTicks.ToString("F0"); break;

            case ValueUnit.Pips:
                // show tenth pips (if available)
                double pips        = Math.Abs(yDiffTicks / 10);
                char   decimalChar = Char.Parse(Core.Globals.GeneralOptions.CurrentCulture.NumberFormat.NumberDecimalSeparator);
                yValueString = Int32.Parse(pips.ToString("F1").Split(decimalChar)[1]) > 0 ? pips.ToString("F1").Replace(decimalChar, '\'') : pips.ToString("F0");
                break;
            }

            TimeSpan timeDiff = EndAnchor.Time - StartAnchor.Time;

            // trim off millis/ticks, match NT7 time formatting
            timeDiff = new TimeSpan(timeDiff.Days, timeDiff.Hours, timeDiff.Minutes, timeDiff.Seconds);

            bool isMultiDay = Math.Abs(timeDiff.TotalHours) >= 24;

            if (chartBars.Bars.BarsPeriod.BarsPeriodType == BarsPeriodType.Day)
            {
                int timeDiffDay = Math.Abs(timeDiff.Days);
                timeText = timeDiffDay > 1 ? Math.Abs(timeDiff.Days) + " " + Custom.Resource.Days  : Math.Abs(timeDiff.Days) + " " + Custom.Resource.Day;
            }
            else
            {
                timeText = isMultiDay ? string.Format("{0}\n{1,25}",
                                                      string.Format(Custom.Resource.NinjaScriptDrawingToolRulerDaysFormat, Math.Abs(timeDiff.Days)),
                                                      timeDiff.Subtract(new TimeSpan(timeDiff.Days, 0, 0, 0)).Duration().ToString()) : timeDiff.Duration().ToString();
            }

            Point startPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
            Point endPoint   = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
            int   startIdx   = chartBars.GetBarIdxByX(chartControl, (int)startPoint.X);
            int   endIdx     = chartBars.GetBarIdxByX(chartControl, (int)endPoint.X);
            int   numBars    = endIdx - startIdx;

            SimpleFont wpfFont = chartControl.Properties.LabelFont ?? new SimpleFont();

            textFormat = wpfFont.ToDirectWriteTextFormat();
            textFormat.TextAlignment = SharpDX.DirectWrite.TextAlignment.Leading;
            textFormat.WordWrapping  = SharpDX.DirectWrite.WordWrapping.NoWrap;
            // format text to our text rectangle bounds (it will wrap to these constraints), nt7 format
            // NOTE: Environment.NewLine doesnt work right here
            string text = string.Format("{0}\n{1,-11}{2,-11}\n{3,-11}{4,-11}\n{5,-10}{6,-10}",
                                        AttachedTo.DisplayName,
                                        Custom.Resource.NinjaScriptDrawingToolRulerNumberBarsText, numBars,
                                        Custom.Resource.NinjaScriptDrawingToolRulerTimeText, timeText,
                                        Custom.Resource.NinjaScriptDrawingToolRulerYValueText, yValueString);

            // give big values for max width/height, we will trim to actual used
            textLayout = new SharpDX.DirectWrite.TextLayout(Core.Globals.DirectWriteFactory, text, textFormat, 600, 600);
            // use measured max width/height
            textLayout.MaxWidth  = textLayout.Metrics.Width;
            textLayout.MaxHeight = textLayout.Metrics.Height;
            isTextCreated        = true;
        }
예제 #16
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars bars = chartBars.Bars;

            if (chartBars.FromIndex > 0)
            {
                chartBars.FromIndex--;
            }

            SharpDX.Direct2D1.PathGeometry lineGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
            AntialiasMode oldAliasMode = RenderTarget.AntialiasMode;
            GeometrySink  sink         = lineGeometry.Open();

            sink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(bars.GetClose(chartBars.FromIndex > -1 ? chartBars.FromIndex : 0))), FigureBegin.Filled);

            for (int idx = chartBars.FromIndex + 1; idx <= chartBars.ToIndex; idx++)
            {
                double closeValue = bars.GetClose(idx);
                float  close      = chartScale.GetYByValue(closeValue);
                float  x          = chartControl.GetXByBarIndex(chartBars, idx);
                sink.AddLine(new Vector2(x, close));
            }

            sink.EndFigure(FigureEnd.Open);
            sink.Close();
            RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
            RenderTarget.DrawGeometry(lineGeometry, UpBrushDX, (float)Math.Max(1, chartBars.Properties.ChartStyle.BarWidth));
            lineGeometry.Dispose();

            SharpDX.Direct2D1.SolidColorBrush fillOutline  = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.Transparent);
            SharpDX.Direct2D1.PathGeometry    fillGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
            GeometrySink fillSink = fillGeometry.Open();

            fillSink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(chartScale.MinValue)), FigureBegin.Filled);
            float fillx = float.NaN;

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                double closeValue = bars.GetClose(idx);
                float  close      = chartScale.GetYByValue(closeValue);
                fillx = chartControl.GetXByBarIndex(chartBars, idx);
                fillSink.AddLine(new Vector2(fillx, close));
            }
            if (!double.IsNaN(fillx))
            {
                fillSink.AddLine(new Vector2(fillx, chartScale.GetYByValue(chartScale.MinValue)));
            }

            fillSink.EndFigure(FigureEnd.Open);
            fillSink.Close();
            DownBrushDX.Opacity = Opacity / 100f;
            if (!(DownBrushDX is SharpDX.Direct2D1.SolidColorBrush))
            {
                TransformBrush(DownBrushDX, new RectangleF(0, 0, (float)chartScale.Width, (float)chartScale.Height));
            }
            RenderTarget.FillGeometry(fillGeometry, DownBrushDX);
            RenderTarget.DrawGeometry(fillGeometry, fillOutline, (float)chartBars.Properties.ChartStyle.BarWidth);
            fillOutline.Dispose();
            RenderTarget.AntialiasMode = oldAliasMode;
            fillGeometry.Dispose();
        }
예제 #17
0
        // Draw objects after any reload of data (if possible)
        // currently wont restore if one of points is -1 (unfinished bar, when calc per bar close)
        private void RestoreDrawObjects()
        {
            //check all dates for bars to validate they exist.
            //if(APDate == DateTime.MinValue) return;	//works, but could still be older than oldest bar.
            //make sure All our saved dates are available on chart (null save = 01/01/0001).
            DateTime oldestDate = Time[CurrentBar];

            if (oldestDate > APDate || oldestDate > BPDate || oldestDate > CPDate)
            {
                return;
            }
            if (Time[0] < APDate || Time[0] < BPDate || Time[0] < CPDate)
            {
                return;
            }

            swingDir   = APVal >= BPVal ? -1 : 1;
            swingColor = swingDir > 0 ? SwingColorUp : SwingColorDn;

            //Draw AB line and text, using date info
            lineAB = Draw.Line(this, "dDwABLine", false, APDate, APVal, BPDate, BPVal, swingColor, DashStyleHelper.Solid, 2);
            lineBC = Draw.Line(this, "dDwBCLine", false, BPDate, BPVal, CPDate, CPVal, swingColor, DashStyleHelper.Solid, 2);

            //ChartControl.InvalidateVisual();
            ForceRefresh();

            //Place 'A' text
            Draw.Text(this, "dDwALabel", IsAutoScale, "A",
                      APDate, APVal, textOffset2 * swingDir * -1, swingColor, textFontLabel,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);
            Draw.Text(this, "dDwAPct", IsAutoScale, APVal.ToString(),
                      APDate, APVal, textOffset * swingDir * -1, swingColor, textFont,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);

            //Place 'B' text
            double moveVal = RoundInst(Math.Abs(APVal - BPVal));

            Draw.Text(this, "dDwBLabel", IsAutoScale, "B",
                      BPDate, BPVal, textOffset2 * swingDir, swingColor, textFontLabel,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);
            Draw.Text(this, "dDwBPrice", IsAutoScale, moveVal.ToString() + "c - " + BPVal.ToString(),
                      BPDate, BPVal, textOffset * swingDir, swingColor, textFont,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);

            //Draw 'C' text
            moveVal = RoundInst(Math.Abs(BPVal - CPVal));
            double movePct = (moveVal / Math.Abs(APVal - BPVal)) * 100;

            Draw.Text(this, "dDwCLabel", IsAutoScale, "C",
                      CPDate, CPVal, textOffset3 * swingDir * -1, swingColor, textFontLabel,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);
            //move point value and %
            Draw.Text(this, "dDwCPct", IsAutoScale, movePct.ToString("f1") + "%",
                      CPDate, CPVal, textOffset2 * swingDir * -1, swingColor, textFont,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);
            Draw.Text(this, "dDwCPrice", IsAutoScale, moveVal.ToString() + "c - " + CPVal.ToString(),
                      CPDate, CPVal, textOffset * swingDir * -1, swingColor, textFont,
                      TextAlignment.Center, Brushes.Transparent, Brushes.Transparent, 0);

            //setup and call fib draws
            _ABbarStart   = CurrentBar - ChartBars.GetBarIdxByTime(ChartControl, APDate);
            _ABbarEnd     = CurrentBar - ChartBars.GetBarIdxByTime(ChartControl, BPDate);
            _ABpriceStart = APVal;
            _ABpriceEnd   = BPVal;
            _BCbarStart   = _ABbarEnd;
            _BCbarEnd     = CurrentBar - ChartBars.GetBarIdxByTime(ChartControl, CPDate);
            _BCpriceStart = BPVal;
            _BCpriceEnd   = CPVal;

            DoDrawFibs(1, FibABRets, FibABExtends, FibABColor);
            DoDrawFibs(2, FibBCRets, FibBCExtends, FibBCColor);
            DoDrawFibs(3, FibMMRets, FibMMExtends, swingColor);
        }
예제 #18
0
        private void DrawPriceText(ChartAnchor anchor, Point point, double price, ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale)
        {
            if (TextAlignment == TextLocation.Off)
            {
                return;
            }

            string    priceString;
            ChartBars chartBars = GetAttachedToChartBars();

            // bars can be null while chart is initializing
            if (chartBars == null)
            {
                return;
            }

            priceString = GetPriceString(price, chartBars);

            Stroke color;

            textleftPoint  = RiskAnchor.GetPoint(chartControl, chartPanel, chartScale).X;
            textRightPoint = EntryAnchor.GetPoint(chartControl, chartPanel, chartScale).X;

            if (anchor == RewardAnchor)
            {
                color = TargetLineStroke;
            }
            else if (anchor == RiskAnchor)
            {
                color = StopLineStroke;
            }
            else if (anchor == EntryAnchor)
            {
                color = EntryLineStroke;
            }
            else
            {
                color = AnchorLineStroke;
            }

            SimpleFont wpfFont = chartControl.Properties.LabelFont ?? new SimpleFont();

            SharpDX.DirectWrite.TextFormat textFormat = wpfFont.ToDirectWriteTextFormat();
            textFormat.TextAlignment = SharpDX.DirectWrite.TextAlignment.Leading;
            textFormat.WordWrapping  = SharpDX.DirectWrite.WordWrapping.NoWrap;
            SharpDX.DirectWrite.TextLayout textLayout = new SharpDX.DirectWrite.TextLayout(Core.Globals.DirectWriteFactory, priceString, textFormat, chartPanel.H, textFormat.FontSize);

            if (RiskAnchor.Time <= EntryAnchor.Time)
            {
                if (!IsExtendedLinesLeft && !IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.InsideRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;

                    case TextLocation.ExtremeLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.ExtremeRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;
                    }
                }
                else if (IsExtendedLinesLeft && !IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.InsideRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;

                    case TextLocation.ExtremeLeft: point.X = chartPanel.X;                                                               break;

                    case TextLocation.ExtremeRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;
                    }
                }
                else if (!IsExtendedLinesLeft && IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.InsideRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;

                    case TextLocation.ExtremeLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.ExtremeRight: point.X = chartPanel.W - textLayout.Metrics.Width;    break;
                    }
                }
                else if (IsExtendedLinesLeft && IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textleftPoint;                                                              break;

                    case TextLocation.InsideRight: point.X = textRightPoint - textLayout.Metrics.Width;  break;

                    case TextLocation.ExtremeRight: point.X = chartPanel.W - textLayout.Metrics.Width;    break;

                    case TextLocation.ExtremeLeft: point.X = chartPanel.X;                                                               break;
                    }
                }
            }
            else if (RiskAnchor.Time >= EntryAnchor.Time)
            {
                if (!IsExtendedLinesLeft && !IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.InsideRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;

                    case TextLocation.ExtremeLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.ExtremeRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;
                    }
                }
                else if (IsExtendedLinesLeft && !IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.InsideRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;

                    case TextLocation.ExtremeLeft: point.X = chartPanel.X;                                                               break;

                    case TextLocation.ExtremeRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;
                    }
                }
                else if (!IsExtendedLinesLeft && IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.InsideRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;

                    case TextLocation.ExtremeLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.ExtremeRight: point.X = chartPanel.W - textLayout.Metrics.Width;    break;
                    }
                }
                else if (IsExtendedLinesLeft && IsExtendedLinesRight)
                {
                    switch (TextAlignment)
                    {
                    case TextLocation.InsideLeft: point.X = textRightPoint;                                                             break;

                    case TextLocation.InsideRight: point.X = textleftPoint - textLayout.Metrics.Width;   break;

                    case TextLocation.ExtremeRight: point.X = chartPanel.W - textLayout.Metrics.Width;    break;

                    case TextLocation.ExtremeLeft: point.X = chartPanel.X;                                                               break;
                    }
                }
            }

            RenderTarget.DrawTextLayout(new SharpDX.Vector2((float)point.X, (float)point.Y), textLayout, color.BrushDX, SharpDX.Direct2D1.DrawTextOptions.NoSnap);
        }
예제 #19
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars       bars     = chartBars.Bars;
            float      barWidth = GetBarPaintWidth(BarWidthUI);
            Vector2    point0   = new Vector2();
            Vector2    point1   = new Vector2();
            RectangleF rect     = new RectangleF();

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                Brush  overriddenBarBrush     = chartControl.GetBarOverrideBrush(chartBars, idx);
                Brush  overriddenOutlineBrush = chartControl.GetCandleOutlineOverrideBrush(chartBars, idx);
                double closeValue             = bars.GetClose(idx);
                int    close     = chartScale.GetYByValue(closeValue);
                int    high      = chartScale.GetYByValue(bars.GetHigh(idx));
                int    low       = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue = bars.GetOpen(idx);
                int    open      = chartScale.GetYByValue(openValue);
                int    x         = chartControl.GetXByBarIndex(chartBars, idx);

                if (Math.Abs(open - close) < 0.0000001)
                {
                    // Line
                    point0.X = x - barWidth * 0.5f;
                    point0.Y = close;
                    point1.X = x + barWidth * 0.5f;
                    point1.Y = close;
                    Brush b = overriddenOutlineBrush ?? Stroke.BrushDX;
                    if (!(b is SolidColorBrush))
                    {
                        TransformBrush(overriddenOutlineBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                    }
                    RenderTarget.DrawLine(point0, point1, b, Stroke.Width, Stroke.StrokeStyle);
                }
                else
                {
                    // Candle
                    rect.X      = x - barWidth * 0.5f + 0.5f;
                    rect.Y      = Math.Min(close, open);
                    rect.Width  = barWidth - 1;
                    rect.Height = Math.Max(open, close) - Math.Min(close, open);
                    Brush brush = overriddenBarBrush ?? (closeValue >= openValue ? UpBrushDX : DownBrushDX);
                    if (!(brush is SolidColorBrush))
                    {
                        TransformBrush(brush, rect);
                    }
                    RenderTarget.FillRectangle(rect, brush);
                    brush = overriddenOutlineBrush ?? Stroke.BrushDX;
                    if (!(brush is SolidColorBrush))
                    {
                        TransformBrush(brush, rect);
                    }
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                }

                Brush br = overriddenOutlineBrush ?? Stroke2.BrushDX;

                // High wick
                if (high < Math.Min(open, close))
                {
                    point0.X = x;
                    point0.Y = high;
                    point1.X = x;
                    point1.Y = Math.Min(open, close);
                    if (!(br is SolidColorBrush))
                    {
                        TransformBrush(br, new RectangleF(point0.X - Stroke2.Width, point0.Y, Stroke2.Width, point1.Y - point0.Y));
                    }
                    RenderTarget.DrawLine(point0, point1, br, Stroke2.Width, Stroke2.StrokeStyle);
                }

                // Low wick
                if (low > Math.Max(open, close))
                {
                    point0.X = x;
                    point0.Y = low;
                    point1.X = x;
                    point1.Y = Math.Max(open, close);
                    if (!(br is SolidColorBrush))
                    {
                        TransformBrush(br, new RectangleF(point1.X - Stroke2.Width, point1.Y, Stroke2.Width, point0.Y - point1.Y));
                    }
                    RenderTarget.DrawLine(point0, point1, br, Stroke2.Width, Stroke2.StrokeStyle);
                }
            }
        }
예제 #20
0
파일: TimeCycles.cs 프로젝트: theprofe8/nt8
        public override void OnRender(ChartControl chartControl, ChartScale chartScale)
        {
            if (firstTime && DrawingState == DrawingState.Normal)
            {
                firstTime = false;
                Cbi.License.Log("TimeCycles");
            }

            ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
            ChartBars  chartBars  = GetChartBars();
            int        startX     = Convert.ToInt32(StartAnchor.GetPoint(chartControl, chartPanel, chartScale).X);

            diameter = Math.Abs(startX - Convert.ToInt32(EndAnchor.GetPoint(chartControl, chartPanel, chartScale).X));
            radius   = Convert.ToInt32(diameter / 2.0);

            if (radius <= 0)
            {
                return;
            }

            UpdateAnchors(chartControl, chartBars, startX);

            if (anchorBars.Count <= 2)
            {
                return;
            }

            RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;
            OutlineStroke.RenderTarget = RenderTarget;

            // dont bother with an area brush if we're doing a hit test (software) render pass. we do not render area then.
            // this allows us to select something behind our area brush (like NT7)
            bool renderArea = false;

            if (!IsInHitTest && AreaBrush != null)
            {
                if (areaBrushDevice.Brush == null)
                {
                    Brush brushCopy = areaBrush.Clone();
                    brushCopy.Opacity     = areaOpacity / 100d;
                    areaBrushDevice.Brush = brushCopy;
                }

                areaBrushDevice.RenderTarget = RenderTarget;
                renderArea = true;
            }
            else
            {
                areaBrushDevice.RenderTarget = null;
                areaBrushDevice.Brush        = null;
            }

            for (int i = 0; i < anchorBars.Count - 1; i++)
            {
                SharpDX.Direct2D1.Ellipse ellipse = new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(anchorBars[i] + radius, chartPanel.Y + chartPanel.H), radius, radius);

                if (renderArea)
                {
                    RenderTarget.FillEllipse(ellipse, areaBrushDevice.BrushDX);
                }

                SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : OutlineStroke.BrushDX;
                RenderTarget.DrawEllipse(ellipse, tmpBrush);
            }
        }
예제 #21
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars bars = chartBars.Bars;

            if (chartBars.FromIndex > 0)
            {
                chartBars.FromIndex--;
            }

            SharpDX.Direct2D1.PathGeometry lineGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
            GeometrySink sink = lineGeometry.Open();

            sink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(bars.GetClose(chartBars.FromIndex > -1 ? chartBars.FromIndex : 0))), FigureBegin.Filled);

            for (int idx = chartBars.FromIndex + 1; idx <= chartBars.ToIndex; idx++)
            {
                double closeValue = bars.GetClose(idx);
                float  close      = chartScale.GetYByValue(closeValue);
                float  x          = chartControl.GetXByBarIndex(chartBars, idx);
                sink.AddLine(new Vector2(x, close));
            }

            sink.EndFigure(FigureEnd.Open);
            sink.Close();
            AntialiasMode oldAliasMode = RenderTarget.AntialiasMode;

            RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
            RenderTarget.DrawGeometry(lineGeometry, UpBrushDX, (float)Math.Max(1, chartBars.Properties.ChartStyle.BarWidth));
            RenderTarget.AntialiasMode = oldAliasMode;
            lineGeometry.Dispose();
        }
예제 #22
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale)
        {
            if (Series1 == null)
            {
                return;
            }

            NinjaScriptBase nsb       = AttachedTo.ChartObject as NinjaScriptBase;
            ChartBars       chartBars = (AttachedTo.ChartObject as Gui.NinjaScript.IChartBars).ChartBars;

            if (nsb == null || chartBars == null || Math.Abs(Series1.Count - chartBars.Count) > 1)
            {
                return;
            }

            int startBarIdx;
            int endBarIdx;

            if (chartControl.BarSpacingType == BarSpacingType.TimeBased)
            {
                startBarIdx = chartBars.GetBarIdxByTime(chartControl, StartAnchor.Time);
                endBarIdx   = chartBars.GetBarIdxByTime(chartControl, EndAnchor.Time);
            }
            else
            {
                startBarIdx = StartAnchor.DrawnOnBar - StartAnchor.BarsAgo;
                endBarIdx   = EndAnchor.DrawnOnBar - EndAnchor.BarsAgo;

                if (startBarIdx == endBarIdx)
                {
                    startBarIdx = chartBars.GetBarIdxByTime(chartControl, StartAnchor.Time);
                    endBarIdx   = chartBars.GetBarIdxByTime(chartControl, EndAnchor.Time);
                }
            }

            int startIdx = Math.Min(startBarIdx, endBarIdx);
            int endIdx   = Math.Max(startBarIdx, endBarIdx);

            // Now cap start/end by visibly painted bars!
            // If you dont do this it will absolutely crush performance on larger regions
            int firstVisibleIdx = Math.Max(nsb.BarsRequiredToPlot + Displacement, chartBars.GetBarIdxByTime(chartControl, chartControl.GetTimeByX(0)) - 1);
            int lastVisibleIdx  = Math.Max(chartBars.ToIndex, chartBars.GetBarIdxByTime(chartControl, chartControl.LastTimePainted)) + 1;

            // Update indicies for displacement
            startIdx = Math.Max(0, Math.Max(firstVisibleIdx, startIdx + Displacement));
            endIdx   = Math.Max(0, Math.Min(endIdx + Displacement, lastVisibleIdx));

            // we're completely not visible
            if (startIdx > lastVisibleIdx || endIdx < firstVisibleIdx)
            {
                return;
            }

            /* NOTE: Calling GetValueAt() on an ISeries<double> interface with a concrete
             * type of NinjaScriptBase will get the *bar* value which is not what we want,
             * in this case, default to first values (indicator) series */
            ISeries <double> series1Adjusted = Series1;
            ISeries <double> series2Adjusted = Series2;

            NinjaScriptBase series1NsBase = Series1 as NinjaScriptBase;

            if (series1NsBase != null)
            {
                series1Adjusted = series1NsBase.Value;
            }

            if (series1Adjusted == null)
            {
                return;
            }

            NinjaScriptBase series2NsBase = Series2 as NinjaScriptBase;

            if (series2NsBase != null)
            {
                series2Adjusted = series2NsBase.Value;
            }

            // take care to wind the points correctly so our geometry builds as a solid, not flipped inside out
            SharpDX.Vector2[] points;
            SharpDX.Vector2[] points2 = new SharpDX.Vector2[0];
            int pointIdx  = 0;
            int pointIdx2 = 0;

            if (series2Adjusted == null)
            {
                points = new SharpDX.Vector2[endIdx - startIdx + 1 + 2];
                for (int i = startIdx; i <= endIdx; ++i)
                {
                    if (i < Math.Max(0, Displacement) || i > Math.Max(chartBars.Count - (nsb.Calculate == Calculate.OnBarClose ? 2 : 1) + Displacement, endIdx))
                    {
                        continue;
                    }

                    int    displacedIndex = Math.Min(chartBars.Count - (nsb.Calculate == Calculate.OnBarClose ? 2 : 1), Math.Max(0, i - Displacement));
                    double seriesValue    = series1Adjusted.GetValueAt(displacedIndex);
                    float  y = chartScale.GetYByValue(seriesValue);
                    float  x = chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && i >= chartBars.Count                                                    //i is already displaced
                                                ? chartControl.GetXByTime(chartBars.GetTimeByBarIdx(chartControl, i))
                                                : chartControl.GetXByBarIndex(chartBars, i);

                    double pixXAdjust     = x % 1 != 0 ? 0 : 0.5d;
                    double pixYAdjust     = y % 1 != 0 ? 0 : 0.5d;
                    Vector pixelAdjustVec = new Vector(pixXAdjust, pixYAdjust);

                    Point adjusted = new Point(x, y) + pixelAdjustVec;
                    points[pointIdx] = adjusted.ToVector2();
                    ++pointIdx;
                }

                // cap it end->start
                points[pointIdx].X = chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && endIdx >= chartBars.Count
                                        ? chartControl.GetXByTime(chartBars.GetTimeByBarIdx(chartControl, endIdx))
                                        : chartControl.GetXByBarIndex(chartBars, endIdx);
                points[pointIdx++].Y = chartScale.GetYByValue(Math.Max(chartScale.MinValue, Math.Min(chartScale.MaxValue, Price)));

                points[pointIdx].X = chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && startIdx >= chartBars.Count
                                        ? chartControl.GetXByTime(chartBars.GetTimeByBarIdx(chartControl, startIdx))
                                        : chartControl.GetXByBarIndex(chartBars, startIdx);
                points[pointIdx++].Y = chartScale.GetYByValue(Math.Max(chartScale.MinValue, Math.Min(chartScale.MaxValue, Price)));
            }
            else
            {
                points  = new SharpDX.Vector2[endIdx - startIdx + 1];
                points2 = new SharpDX.Vector2[endIdx - startIdx + 1];
                // fill clockwise from series1, the	counter clockwise for series 2 for correct point poly winding
                for (int i = startIdx; i <= endIdx; ++i)
                {
                    if (i < Math.Max(0, Displacement) || i > Math.Max(chartBars.Count - (nsb.Calculate == Calculate.OnBarClose ? 2 : 1) + Displacement, endIdx))
                    {
                        continue;
                    }

                    int   displacedIndex = Math.Min(chartBars.Count - (nsb.Calculate == Calculate.OnBarClose ? 2 : 1), Math.Max(0, i - Displacement));
                    float x = chartControl.BarSpacingType == BarSpacingType.TimeBased || chartControl.BarSpacingType == BarSpacingType.EquidistantMulti && i >= chartBars.Count                                                     //i is already displaced
                                                ? chartControl.GetXByTime(chartBars.GetTimeByBarIdx(chartControl, i))
                                                : chartControl.GetXByBarIndex(chartBars, i);
                    if (!series1Adjusted.IsValidDataPointAt(displacedIndex))
                    {
                        continue;
                    }
                    double seriesValue = series1Adjusted.GetValueAt(displacedIndex);
                    float  y           = chartScale.GetYByValue(seriesValue);

                    double pixXAdjust = x % 1 != 0 ? 0 : 0.5d;
                    double pixYAdjust = y % 1 != 0 ? 0 : 0.5d;

                    Vector pixelAdjustVec = new Vector(pixXAdjust, pixYAdjust);

                    Point adjusted = new Point(x, y) + pixelAdjustVec;
                    points[pointIdx] = adjusted.ToVector2();
                    ++pointIdx;
                    if (!series2Adjusted.IsValidDataPointAt(displacedIndex))
                    {
                        continue;
                    }
                    seriesValue        = series2Adjusted.GetValueAt(displacedIndex);
                    y                  = chartScale.GetYByValue(seriesValue);
                    pixYAdjust         = y % 1 != 0 ? 0 : 0.5d;
                    pixelAdjustVec     = new Vector(pixXAdjust, pixYAdjust);
                    adjusted           = new Point(x, y) + pixelAdjustVec;
                    points2[pointIdx2] = adjusted.ToVector2();
                    ++pointIdx2;
                }
            }

            if (pointIdx + pointIdx2 > 2)
            {
                RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;

                if (OutlineStroke != null)
                {
                    OutlineStroke.RenderTarget = RenderTarget;
                }

                if (AreaBrush != null)
                {
                    if (areaBrushDevice.Brush == null)
                    {
                        Brush brushCopy = areaBrush.Clone();
                        brushCopy.Opacity     = areaOpacity / 100d;
                        areaBrushDevice.Brush = brushCopy;
                    }
                    areaBrushDevice.RenderTarget = RenderTarget;
                }

                SharpDX.Direct2D1.PathGeometry polyGeo = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
                SharpDX.Direct2D1.GeometrySink geoSink = polyGeo.Open();
                double pixXAdjust     = points[0].X % 1 != 0 ? 0 : 0.5d;
                double pixYAdjust     = points[0].Y % 1 != 0 ? 0 : 0.5d;
                Vector pixelAdjustVec = new Vector(pixXAdjust, pixYAdjust);
                Point  startPt        = new Point(points[0].X, points[0].Y) + pixelAdjustVec;

                geoSink.BeginFigure(startPt.ToVector2(), SharpDX.Direct2D1.FigureBegin.Filled);
                geoSink.SetFillMode(SharpDX.Direct2D1.FillMode.Winding);

                // NOTE: We skip our first point since that is where the path will start
                for (int i = 1; i < pointIdx; i++)
                {
                    geoSink.AddLine(points[i]);
                }
                for (int i = pointIdx2 - 1; i >= 0; i--)
                {
                    geoSink.AddLine(points2[i]);
                }
                geoSink.EndFigure(SharpDX.Direct2D1.FigureEnd.Closed);
                geoSink.Close();

                SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : areaBrushDevice == null ? null : areaBrushDevice.BrushDX;
                if (tmpBrush != null)
                {
                    RenderTarget.FillGeometry(polyGeo, tmpBrush);
                }

                tmpBrush = IsInHitTest ? chartControl.SelectionBrush : OutlineStroke == null ? null : OutlineStroke.BrushDX;
                if (tmpBrush != null)
                {
                    RenderTarget.DrawGeometry(polyGeo, OutlineStroke.BrushDX, OutlineStroke.Width);
                }

                polyGeo.Dispose();
            }
        }