private RadialGradientBrush CreateRadialGradientBrush(DeviceContext context, float width, float height, Color4 color1, Color4 color2, float color1Position, float color2Position)
{
GradientStop[] stops = new GradientStop[2];
//stops[0] = new GradientStop() { Color = new Color4(0.85f, 0, 0, 1.0f), Position = 0.0f };
//stops[1] = new GradientStop() { Color = new Color4(0.22f, 0, 0, 1.0f), Position = 1.0f };
stops[0] = new GradientStop() { Color = color1, Position = color1Position };
stops[1] = new GradientStop() { Color = color2, Position = color2Position };
GradientStopCollection gsc = new GradientStopCollection(context, stops, ExtendMode.Clamp);
RadialGradientBrush brush = new RadialGradientBrush(
context,
new RadialGradientBrushProperties()
{
RadiusX = width / 1.3f,
RadiusY = height / 1.3f,
Center = new Vector2(width / 2.0f, height / 2.0f),
GradientOriginOffset = new Vector2(0, 0)
},
gsc);
return brush;
}
public static RadialBrush CreateRadailBrush(RadialData r)
{
RadialBrush rgb;
lock (D2D)
{
D2D1.GradientStopCollection gsc = new D2D1.GradientStopCollection(D2D.d2dContext, r.data, D2D1.ExtendMode.Clamp);
rgb = new RadialBrush(D2D.d2dContext, r.Point, gsc);
}
return(rgb);
}
public static LinearBrush CreateLinearBrush(LinearData l)
{
LinearBrush lgb;
lock (D2D)
{
D2D1.GradientStopCollection gsc = new D2D1.GradientStopCollection(D2D.d2dContext, l.data);
lgb = new LinearBrush(D2D.d2dContext, l.Point, gsc);
}
return(lgb);
}
public static LinearGradientBrush New(string name, Direct2DDevice device, LinearGradient linearGradient)
{
using (var d2dGradientStopCollection = new SharpDX.Direct2D1.GradientStopCollection(device,
linearGradient.GradientStops.Select(gs => (SharpDX.Direct2D1.GradientStop)gs).ToArray(),
(SharpDX.Direct2D1.ExtendMode)linearGradient.GradientStops.ExtendMode))
{
var lgbProperties = new LinearGradientBrushProperties()
{
StartPoint = linearGradient.StartPoint, EndPoint = linearGradient.EndPoint
};
var brushProperties = new BrushProperties()
{
Opacity = linearGradient.Opacity
};
var brush = new SharpDX.Direct2D1.LinearGradientBrush(device, lgbProperties, brushProperties, d2dGradientStopCollection);
return(new LinearGradientBrush(name, device, linearGradient, brush));
}
}
internal override void Create()
{
if (NativeBrush != null)
NativeBrush.Dispose();
var stops = new GradientStop[m_gradientStops.Length];
for (int s = 0; s < m_gradientStops.Length; s++)
{
stops[s].Color = m_gradientStops[s].Color.ToColor4();
stops[s].Position = m_gradientStops[s].Position;
}
using (var stopcol = new GradientStopCollection(Owner.D2dRenderTarget, stops, (Gamma)m_gamma, (ExtendMode)m_extendMode))
{
var props = new LinearGradientBrushProperties();
props.StartPoint = new DrawingPointF(m_start.X, m_start.Y);
props.EndPoint = new DrawingPointF(m_end.X, m_end.Y);
NativeBrush = new LinearGradientBrush(Owner.D2dRenderTarget, props, stopcol);
}
}
public static RadialGradientBrush New(string name, Direct2DDevice device, RadialGradient radialGradient)
{
using (var d2dGradientStopCollection = new SharpDX.Direct2D1.GradientStopCollection(device,
radialGradient.GradientStops.Select(gs => (SharpDX.Direct2D1.GradientStop)gs).ToArray(),
(SharpDX.Direct2D1.ExtendMode)radialGradient.GradientStops.ExtendMode))
{
var rgbProperties = new RadialGradientBrushProperties
{
Center = radialGradient.Center,
GradientOriginOffset = radialGradient.OriginOffset,
RadiusX = radialGradient.RadiusX,
RadiusY = radialGradient.RadiusY
};
var brushProperties = new BrushProperties()
{
Opacity = radialGradient.Opacity
};
var brush = new SharpDX.Direct2D1.RadialGradientBrush(device, rgbProperties, brushProperties, d2dGradientStopCollection);
return(new RadialGradientBrush(name, device, radialGradient, brush));
}
}
protected override void PostInitDirectXResources()
{
_frequencyTextFormat = new DW.TextFormat(DwFactory, "Consolas", DW.FontWeight.Bold,
DW.FontStyle.Normal, DW.FontStretch.Normal, Paradigm.Config.Gui.ButtonFontSize / 3.0F * 2.0F * ScaleFactor)
{
TextAlignment = DW.TextAlignment.Center,
ParagraphAlignment = DW.ParagraphAlignment.Far
};
var gradientStopCollection = new D2D1.GradientStopCollection(RenderTarget, new[]
{
new D2D1.GradientStop
{
Color = ButtonFlashingColor,
Position = 0,
},
new D2D1.GradientStop
{
Color = ButtonNormalColor,
Position = 1,
},
}, D2D1.ExtendMode.Clamp);
_radialGradientBrush = new D2D1.RadialGradientBrush(RenderTarget, new D2D1.RadialGradientBrushProperties(), gradientStopCollection);
}
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
{
// This sample should be used along side the help guide educational resource on this topic:
// http://www.ninjatrader.com/support/helpGuides/nt8/en-us/?using_sharpdx_for_custom_chart_rendering.htm
// Default plotting in base class. Uncomment if indicators holds at least one plot
// in this case we would expect NOT to see the SMA plot we have as well in this sample script
//base.OnRender(chartControl, chartScale);
// 1.1 - SharpDX Vectors and Charting RenderTarget Coordinates
// The SharpDX SDK uses "Vector2" objects to describe a two-dimensional point of a device (X and Y coordinates)
SharpDX.Vector2 startPoint;
SharpDX.Vector2 endPoint;
// For our custom script, we need a way to determine the Chart's RenderTarget coordinates to draw our custom shapes
// This info can be found within the NinjaTrader.Gui.ChartPanel class.
// You can also use various chartScale and chartControl members to calculate values relative to time and price
// However, those concepts will not be discussed or used in this sample
// Notes: RenderTarget is always the full ChartPanel, so we need to be mindful which sub-ChartPanel we're dealing with
// Always use ChartPanel X, Y, W, H - as chartScale and chartControl properties WPF units, so they can be drastically different depending on DPI set
startPoint = new SharpDX.Vector2(ChartPanel.X, ChartPanel.Y);
endPoint = new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, ChartPanel.Y + ChartPanel.H);
// These Vector2 objects are equivalent with WPF System.Windows.Point and can be used interchangeably depending on your requirements
// For convenience, NinjaTrader provides a "ToVector2()" extension method to convert from WPF Points to SharpDX.Vector2
SharpDX.Vector2 startPoint1 = new System.Windows.Point(ChartPanel.X, ChartPanel.Y + ChartPanel.H).ToVector2();
SharpDX.Vector2 endPoint1 = new System.Windows.Point(ChartPanel.X + ChartPanel.W, ChartPanel.Y).ToVector2();
// SharpDX.Vector2 objects contain X/Y properties which are helpful to recalculate new properties based on the initial vector
float width = endPoint.X - startPoint.X;
float height = endPoint.Y - startPoint.Y;
// Or you can recalculate a new vector from existing vector objects
SharpDX.Vector2 center = (startPoint + endPoint) / 2;
// Tip: This check is simply added to prevent the Indicator dialog menu from opening as a user clicks on the chart
// The default behavior is to open the Indicator dialog menu if a user double clicks on the indicator
// (i.e, the indicator falls within the RenderTarget "hit testing")
// You can remove this check if you want the default behavior implemented
if (!IsInHitTest)
{
// 1.2 - SharpDX Brush Resources
// RenderTarget commands must use a special brush resource defined in the SharpDX.Direct2D1 namespace
// These resources exist just like you will find in the WPF/Windows.System.Media namespace
// such as SolidColorBrushes, LienarGraidentBrushes, RadialGradientBrushes, etc.
// To begin, we will start with the most basic "Brush" type
// Warning: Brush objects must be disposed of after they have been used
SharpDX.Direct2D1.Brush areaBrushDx;
SharpDX.Direct2D1.Brush smallAreaBrushDx;
SharpDX.Direct2D1.Brush textBrushDx;
// for convenience, you can simply convert a WPF Brush to a DXBrush using the ToDxBrush() extension method provided by NinjaTrader
// This is a common approach if you have a Brush property created e.g., on the UI you wish to use in custom rendering routines
areaBrushDx = areaBrush.ToDxBrush(RenderTarget);
smallAreaBrushDx = smallAreaBrush.ToDxBrush(RenderTarget);
textBrushDx = textBrush.ToDxBrush(RenderTarget);
// However - it should be noted that this conversion process can be rather expensive
// If you have many brushes being created, and are not tied to WPF resources
// You should rather favor creating the SharpDX Brush directly:
// Warning: SolidColorBrush objects must be disposed of after they have been used
SharpDX.Direct2D1.SolidColorBrush customDXBrush = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget,
SharpDX.Color.DodgerBlue);
// 1.3 - Using The RenderTarget
// before executing chart commands, you have the ability to describe how the RenderTarget should render
// for example, we can store the existing RenderTarget AntialiasMode mode
// then update the AntialiasMode to be the quality of non-text primitives are rendered
SharpDX.Direct2D1.AntialiasMode oldAntialiasMode = RenderTarget.AntialiasMode;
RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.Aliased;
// Note: The code above stores the oldAntialiasMode as a best practices
// i.e., if you plan on changing a property of the RenderTarget, you should plan to set it back
// This is to make sure your requirements to no interfere with the function of another script
// Additionally smoothing has some performance impacts
// Once you have defined all the necessary requirements for you object
// You can execute a command on the RenderTarget to draw specific shapes
// e.g., we can now use the RenderTarget's DrawLine() command to render a line
// using the start/end points and areaBrushDx objects defined before
RenderTarget.DrawLine(startPoint, endPoint, areaBrushDx, 4);
// Since rendering occurs in a sequential fashion, after you have executed a command
// you can switch a property of the RenderTarget to meet other requirements
// For example, we can draw a second line now which uses a different AntialiasMode
// and the changes render on the chart for both lines from the time they received commands
RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;
RenderTarget.DrawLine(startPoint1, endPoint1, areaBrushDx, 4);
// 1.4 - Rendering Custom Shapes
// SharpDX namespace consists of several shapes you can use to draw objects more complicated than lines
// For example, we can use the RectangleF object to draw a rectangle that covers the entire chart area
SharpDX.RectangleF rect = new SharpDX.RectangleF(startPoint.X, startPoint.Y, width, height);
// The RenderTarget consists of two commands related to Rectangles.
// The FillRectangle() method is used to "Paint" the area of a Rectangle
RenderTarget.FillRectangle(rect, areaBrushDx);
// and DrawRectangle() is used to "Paint" the outline of a Rectangle
RenderTarget.DrawRectangle(rect, customDXBrush, 2);
// Another example is an ellipse which can be used to draw circles
// The ellipse center point can be used from the Vectors calculated earlier
// The width and height an absolute 100 device pixels
// To ensure that pixel coordinates work across all DPI devices, we use the NinjaTrader ChartingExteions methods
// Which will convert the "100" value from WPF pixels to Device Pixels both vertically and horizontally
int ellipseRadiusY = ChartingExtensions.ConvertToVerticalPixels(100, ChartControl.PresentationSource);
int ellipseRadiusX = ChartingExtensions.ConvertToHorizontalPixels(100, ChartControl.PresentationSource);
SharpDX.Direct2D1.Ellipse ellipse = new SharpDX.Direct2D1.Ellipse(center, ellipseRadiusX, ellipseRadiusY);
// 1.5 - Complex Brush Types and Shapes
// For this ellipse, we can use one of the more complex brush types "RadialGradientBrush"
// Warning: RadialGradientBrush objects must be disposed of after they have been used
SharpDX.Direct2D1.RadialGradientBrush radialGradientBrush;
// However creating a RadialGradientBrush requires a few more properties than SolidColorBrush
// First, you need to define the array gradient stops the brush will eventually use
SharpDX.Direct2D1.GradientStop[] gradientStops = new SharpDX.Direct2D1.GradientStop[2];
// With the gradientStops array, we can describe the color and position of the individual gradients
gradientStops[0].Color = SharpDX.Color.Goldenrod;
gradientStops[0].Position = 0.0f;
gradientStops[1].Color = SharpDX.Color.SeaGreen;
gradientStops[1].Position = 1.0f;
// then declare a GradientStopCollection from our render target that uses the gradientStops array defined just before
// Warning: GradientStopCollection objects must be disposed of after they have been used
SharpDX.Direct2D1.GradientStopCollection gradientStopCollection =
new SharpDX.Direct2D1.GradientStopCollection(RenderTarget, gradientStops);
// we also need to tell our RadialGradientBrush to match the size and shape of the ellipse that we will be drawing
// for convenience, SharpDX provides a RadialGradientBrushProperties structure to help define these properties
SharpDX.Direct2D1.RadialGradientBrushProperties radialGradientBrushProperties =
new SharpDX.Direct2D1.RadialGradientBrushProperties
{
GradientOriginOffset = new SharpDX.Vector2(0, 0),
Center = ellipse.Point,
RadiusX = ellipse.RadiusY,
RadiusY = ellipse.RadiusY
};
// we now have everything we need to create a radial gradient brush
radialGradientBrush = new SharpDX.Direct2D1.RadialGradientBrush(RenderTarget, radialGradientBrushProperties,
gradientStopCollection);
// Finally, we can use this radialGradientBrush to "Paint" the area of the ellipse
RenderTarget.FillEllipse(ellipse, radialGradientBrush);
// 1.6 - Simple Text Rendering
// For rendering custom text to the Chart, there are a few ways you can approach depending on your requirements
// The most straight forward way is to "borrow" the existing chartControl font provided as a "SimpleFont" class
// Using the chartControl LabelFont, your custom object will also change to the user defined properties allowing
// your object to match different fonts if defined by user.
// The code below will use the chartControl Properties Label Font if it exists,
// or fall back to a default property if it cannot obtain that value
NinjaTrader.Gui.Tools.SimpleFont simpleFont = chartControl.Properties.LabelFont ?? new NinjaTrader.Gui.Tools.SimpleFont("Arial", 12);
// the advantage of using a SimpleFont is they are not only very easy to describe
// but there is also a convenience method which can be used to convert the SimpleFont to a SharpDX.DirectWrite.TextFormat used to render to the chart
// Warning: TextFormat objects must be disposed of after they have been used
SharpDX.DirectWrite.TextFormat textFormat1 = simpleFont.ToDirectWriteTextFormat();
// Once you have the format of the font, you need to describe how the font needs to be laid out
// Here we will create a new Vector2() which draws the font according to the to top left corner of the chart (offset by a few pixels)
SharpDX.Vector2 upperTextPoint = new SharpDX.Vector2(ChartPanel.X + 10, ChartPanel.Y + 20);
// Warning: TextLayout objects must be disposed of after they have been used
SharpDX.DirectWrite.TextLayout textLayout1 =
new SharpDX.DirectWrite.TextLayout(NinjaTrader.Core.Globals.DirectWriteFactory,
NinjaTrader.Custom.Resource.SampleCustomPlotUpperLeftCorner, textFormat1, ChartPanel.X + ChartPanel.W,
textFormat1.FontSize);
// With the format and layout of the text completed, we can now render the font to the chart
RenderTarget.DrawTextLayout(upperTextPoint, textLayout1, textBrushDx,
SharpDX.Direct2D1.DrawTextOptions.NoSnap);
// 1.7 - Advanced Text Rendering
// Font formatting and text layouts can get as complex as you need them to be
// This example shows how to use a complete custom font unrelated to the existing user-defined chart control settings
// Warning: TextLayout and TextFormat objects must be disposed of after they have been used
SharpDX.DirectWrite.TextFormat textFormat2 =
new SharpDX.DirectWrite.TextFormat(NinjaTrader.Core.Globals.DirectWriteFactory, "Century Gothic", FontWeight.Bold,
FontStyle.Italic, 32f);
SharpDX.DirectWrite.TextLayout textLayout2 =
new SharpDX.DirectWrite.TextLayout(NinjaTrader.Core.Globals.DirectWriteFactory,
NinjaTrader.Custom.Resource.SampleCustomPlotLowerRightCorner, textFormat2, 400, textFormat1.FontSize);
// the textLayout object provides a way to measure the described font through a "Metrics" object
// This allows you to create new vectors on the chart which are entirely dependent on the "text" that is being rendered
// For example, we can create a rectangle that surrounds our font based off the textLayout which would dynamically change if the text used in the layout changed dynamically
SharpDX.Vector2 lowerTextPoint = new SharpDX.Vector2(ChartPanel.W - textLayout2.Metrics.Width - 5,
ChartPanel.Y + (ChartPanel.H - textLayout2.Metrics.Height));
SharpDX.RectangleF rect1 = new SharpDX.RectangleF(lowerTextPoint.X, lowerTextPoint.Y, textLayout2.Metrics.Width,
textLayout2.Metrics.Height);
// We can draw the Rectangle based on the TextLayout used above
RenderTarget.FillRectangle(rect1, smallAreaBrushDx);
RenderTarget.DrawRectangle(rect1, smallAreaBrushDx, 2);
// And render the advanced text layout using the DrawTextLayout() method
// Note: When drawing the same text repeatedly, using the DrawTextLayout() method is more efficient than using the DrawText()
// because the text doesn't need to be formatted and the layout processed with each call
RenderTarget.DrawTextLayout(lowerTextPoint, textLayout2, textBrushDx, SharpDX.Direct2D1.DrawTextOptions.NoSnap);
// 1.8 - Cleanup
// This concludes all of the rendering concepts used in the sample
// However - there are some final clean up processes we should always provided before we are done
// If changed, do not forget to set the AntialiasMode back to the default value as described above as a best practice
RenderTarget.AntialiasMode = oldAntialiasMode;
// We also need to make sure to dispose of every device dependent resource on each render pass
// Failure to dispose of these resources will eventually result in unnecessary amounts of memory being used on the chart
// Although the effects might not be obvious as first, if you see issues related to memory increasing over time
// Objects such as these should be inspected first
areaBrushDx.Dispose();
customDXBrush.Dispose();
gradientStopCollection.Dispose();
radialGradientBrush.Dispose();
smallAreaBrushDx.Dispose();
textBrushDx.Dispose();
textFormat1.Dispose();
textFormat2.Dispose();
textLayout1.Dispose();
textLayout2.Dispose();
}
}
private LinearGradientBrush GetCachedLinearGradientBrush(Color color1, Color color2)
{
long kh = color1.ToArgb(); // high bits
long kl = color2.ToArgb(); // low bits
var colorKey = (kh << 32) | kl;
LinearGradientBrush brush;
if (!m_linearGradients.TryGetValue(colorKey, out brush))
{
var stops = new GradientStop[2];
stops[0].Color = color1.ToColor4();
stops[0].Position = 0;
stops[1].Color = color2.ToColor4();
stops[1].Position = 1;
using (var stopCollection = new GradientStopCollection(m_renderTarget, stops, Gamma.StandardRgb, ExtendMode.Clamp))
{
var props = new LinearGradientBrushProperties();
brush = new LinearGradientBrush(m_renderTarget, props, stopCollection);
}
m_linearGradients.Add(colorKey, brush);
}
return brush;
}
public RadialBrush(D2D1.RenderTarget e, D2D1.RadialGradientBrushProperties a, D2D1.GradientStopCollection g) : base(e, a, g)
{
Opacity = 1;
Transform = Matrix3x2.Identity;
RawCenter = a.Center;
RawRadiusX = a.RadiusX;
RawRadiusY = a.RadiusY;
}
public LinearBrush(D2D1.RenderTarget render, D2D1.LinearGradientBrushProperties radial,
D2D1.GradientStopCollection g) : base(render, radial, g)
{
RawStart = radial.StartPoint;
RawEnd = radial.EndPoint;
}
private void Form1_Load(object sender, EventArgs e)
{
//Init Direct Draw
//Set Rendering properties
RenderTargetProperties renderProp = new RenderTargetProperties()
{
DpiX = 0,
DpiY = 0,
MinLevel = FeatureLevel.Level_10,
PixelFormat = new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied),
Type = RenderTargetType.Hardware,
Usage = RenderTargetUsage.None
};
//set hwnd target properties (permit to attach Direct2D to window)
HwndRenderTargetProperties winProp = new HwndRenderTargetProperties()
{
Hwnd = this.Handle,
PixelSize = new DrawingSize(this.ClientSize.Width, this.ClientSize.Height),
PresentOptions = PresentOptions.Immediately
};
//target creation
target = new WindowRenderTarget(factory, renderProp, winProp);
//create red and white brushes
redBrush = new SharpDX.Direct2D1.SolidColorBrush(target, SharpDX.Color.Red);
whiteBrush = new SharpDX.Direct2D1.SolidColorBrush(target, SharpDX.Color.White);
//create a linear gradient brush
var grad = new LinearGradientBrushProperties()
{
StartPoint = new DrawingPointF(ClientSize.Width / 2, ClientSize.Height / 2),
EndPoint = new DrawingPointF(ClientSize.Width, ClientSize.Height)
};
var stopCollection = new GradientStopCollection(target, new GradientStop[]
{
new GradientStop(){Color=SharpDX.Color.Azure ,Position=0F},
new GradientStop(){Color=SharpDX.Color.Yellow,Position=0.2F},
new GradientStop(){Color=SharpDX.Color.Green,Position=0.4F},
new GradientStop(){Color=SharpDX.Color.Red,Position=1F},
}, ExtendMode.Mirror);
gradient = new SharpDX.Direct2D1.LinearGradientBrush(target, grad, stopCollection);
//create textformat
textFormat = new SharpDX.DirectWrite.TextFormat(factoryWrite, "Arial", 36);
//avoid artifacts
this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
}
internal override void Create()
{
if (NativeBrush != null)
NativeBrush.Dispose();
var stops = new GradientStop[m_gradientStops.Length];
for (int s = 0; s < m_gradientStops.Length; s++)
{
stops[s].Color = m_gradientStops[s].Color.ToColor4();
stops[s].Position = m_gradientStops[s].Position;
}
var props = new RadialGradientBrushProperties
{
Center = m_center.ToSharpDX(),
GradientOriginOffset = m_gradientOriginOffset.ToSharpDX(),
RadiusX = m_radiusX,
RadiusY = m_radiusY
};
using (var stopcol = new GradientStopCollection(Owner.D2dRenderTarget, stops, Gamma.StandardRgb, ExtendMode.Clamp))
{
NativeBrush = new RadialGradientBrush(Owner.D2dRenderTarget, props, stopcol);
}
}
