internal Stock(string name, SeriesTypeEnum seriesType, SeriesTypeOHLC seriesTypeOHLC, ChartPanel chartPanel)
: base(name, seriesType, seriesTypeOHLC, chartPanel)
{
Init();
_chartPanel._chartX.ChartReseted += ChartX_OnChartReseted;
_priceStyleStock = null;
}
private void ReadSeries(XmlNode xRoot)
{
XmlNode xmlSeries = xRoot.SelectSingleNode("SeriesCollection");
if (xmlSeries == null)
{
return;
}
int useablePanelsCount = UseablePanelsCount;
foreach (XmlNode node in xmlSeries.ChildNodes)
{
if (node.Name != "Series")
{
continue;
}
int panelIndex = ConvertFromXmlEx("PanelIndex", node, -1);
if (panelIndex == -1)
{
continue;
}
if (panelIndex >= useablePanelsCount)
{
panelIndex = 0;
}
ChartPanel chartPanel = GetPanelByIndex(panelIndex);
string seriesName = ConvertFromXmlEx("Name", node, string.Empty);
if (seriesName.Length == 0)
{
continue;
}
SeriesTypeEnum seriesTypeSeries = (SeriesTypeEnum)Enum.Parse(typeof(SeriesTypeEnum), ConvertFromXmlEx("SeriesTypeSeries", node, SeriesTypeEnum.stUnknown.ToString()));
SeriesTypeOHLC ohlc = (SeriesTypeOHLC)Enum.Parse(typeof(SeriesTypeOHLC), ConvertFromXmlEx("OHLCType", node, string.Empty));
SeriesTypeEnum seriesType = (SeriesTypeEnum)Enum.Parse(typeof(SeriesTypeEnum), ConvertFromXmlEx("SeriesType", node, string.Empty));
Series series = chartPanel.CreateSeries(seriesName, ohlc, seriesTypeSeries != SeriesTypeEnum.stUnknown ? seriesTypeSeries : seriesType);
if (series == null)
{
continue;
}
series.SeriesType = seriesType;
string upColor = ConvertFromXmlEx("UpColor", node, string.Empty);
string downColor = ConvertFromXmlEx("DownColor", node, string.Empty);
series.StrokeThickness = ConvertFromXmlEx("StrokeThicknes", node, 1.0);
series.StrokeColor = Utils.StringToColor(ConvertFromXmlEx("StrokeColor", node, string.Empty));
series._selectable = ConvertFromXmlEx("Selectable", node, false);
series.Visible = ConvertFromXmlEx("Visible", node, true);
series.StrokePattern = (LinePattern)Enum.Parse(typeof(LinePattern), ConvertFromXmlEx("StrokePattern", node, "Solid"));
series.UpColor = upColor.Length > 0 ? Utils.StringToColor(upColor) : (Color?)null;
series.DownColor = downColor.Length > 0 ? Utils.StringToColor(downColor) : (Color?)null;
series.SeriesIndex = ConvertFromXmlEx("SeriesIndex", node, 0);
_dataManager.AddSeries(series.Name, series.OHLCType);
_dataManager.BindSeries(series);
}
}
public SeriesModelBase(int startIndex, int endIndex, bool isOscillator, SeriesTypeEnum seriesType, Series series)
{
StartIndex = startIndex;
EndIndex = endIndex;
IsOscillator = isOscillator;
SeriesType = seriesType;
Series = series;
}
internal Series(string name, SeriesTypeEnum seriesType, SeriesTypeOHLC seriesTypeOHLC, ChartPanel chartPanel)
{
_name = name;
_seriesType = seriesType;
_chartPanel = chartPanel;
_seriesTypeOHLC = seriesTypeOHLC;
ShowInHeatMap = false;
UseEnhancedColoring = false;
WickUpStroke = new SolidColorBrush(Color.FromArgb(0xFF, 0x00, 0xFF, 0x00)); // Lime
WickDownStroke = new SolidColorBrush(Colors.Red);
WickStrokeThickness = 1.0;
CandleUpFill = new SolidColorBrush(Color.FromArgb(0xFF, 0x00, 0xFF, 0x00)); // Lime
CandleDownFill = new SolidColorBrush(Colors.Red);
CandleUpStroke = null;
CandleDownStroke = null;
CandleStrokeThickness = 0;
}
public static TestSeries Create(SeriesTypeEnum seriesType, ObservableCollection <TestSeriesData> data) => new TestSeries(seriesType, data);
public TestSeries(SeriesTypeEnum seriesType, ObservableCollection <TestSeriesData> data)
{
SeriesType = seriesType;
Data = data;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Unique series name. </param>
/// <param name="seriesType">Series Type</param>
/// <param name="seriesTypeOHLC">Series OHLC type</param>
/// <param name="chartPanel">Reference to a chart panel where it will be placed.</param>
public Standard(string name, SeriesTypeEnum seriesType, SeriesTypeOHLC seriesTypeOHLC,
ChartPanel chartPanel)
: base(name, seriesType, seriesTypeOHLC, chartPanel)
{
Init();
}
internal override void Paint(object drawingContext)
{
//if (_painted) return;
Style ps = null;
if (_priceStyleType != _chartPanel._chartX._priceStyle || _seriesTypeType != _seriesType)
{
if (_chartPanel._chartX._priceStyle != PriceStyleEnum.psStandard)
{
switch (_chartPanel._chartX._priceStyle)
{
case PriceStyleEnum.psKagi:
ps = new Kagi(this);
break;
case PriceStyleEnum.psCandleVolume:
case PriceStyleEnum.psEquiVolume:
case PriceStyleEnum.psEquiVolumeShadow:
ps = new EquiVolume(this);
break;
case PriceStyleEnum.psPointAndFigure:
ps = new PointAndFigure(this);
break;
case PriceStyleEnum.psRenko:
ps = new Renko(this);
break;
case PriceStyleEnum.psThreeLineBreak:
ps = new ThreeLineBreak(this);
break;
case PriceStyleEnum.psHeikinAshi:
ps = new HeikinAshi(this);
break;
}
}
else
{
switch (_seriesType)
{
case SeriesTypeEnum.stCandleChart:
ps = new Candles(this);
break;
case SeriesTypeEnum.stStockBarChartHLC:
case SeriesTypeEnum.stStockBarChart:
ps = new PriceStyles.Stock(this);
break;
case SeriesTypeEnum.stLineChart:
ps = new Linear(this);
break;
}
}
if (_priceStyle != null)
{
_priceStyle.RemovePaint();
}
}
if (_darvasBoxes != null)
{
_darvasBoxes.RemovePaint();
}
if (_chartPanel._chartX._priceStyle == PriceStyleEnum.psStandard || _chartPanel._chartX._priceStyle == PriceStyleEnum.psHeikinAshi)
{
if (_darvasBoxes == null)
{
_darvasBoxes = new DarvasBoxes(this);
}
_darvasBoxes.SetSeriesStock(this);
if (_chartPanel._chartX._darwasBoxes)
{
_darvasBoxes.Paint();
}
}
if (_priceStyle != null || ps != null)
{
(ps ?? _priceStyle).SetStockSeries(this);
Style psToPaint = ps ?? _priceStyle;
bool res;
if (psToPaint is Candles && drawingContext != null)
{
res = psToPaint.Paint(drawingContext);
}
else
{
res = psToPaint.Paint();
}
//if (!(ps ?? _priceStyle).Paint()) return;
if (!res)
{
return;
}
}
if (Selected)
{
ShowSelection();
}
if (ps == null)
{
return;
}
_priceStyle = ps;
_priceStyleType = _chartPanel._chartX._priceStyle;
_seriesTypeType = _seriesType;
}
public SeriesStandardModel(int startIndex, int endIndex, bool isOscillator, SeriesTypeEnum seriesType,
Series series, bool volumeUpDown) :
base(startIndex, endIndex, isOscillator, seriesType, series)
{
VolumeUpDown = volumeUpDown;
}
public void ApplyPriceStyle(string tag, int size = 1)
{
PriceStyleTag = tag;
if (_stockChartX.RecordCount > 0)
{
PriceStyleEnum priceStyle = PriceStyleEnum.psStandard;
SeriesTypeEnum seriesType = SeriesTypeEnum.stCandleChart;
switch (tag)
{
case "bar":
seriesType = SeriesTypeEnum.stStockBarChart;
break;
case "line":
seriesType = SeriesTypeEnum.stLineChart;
break;
case "standard":
priceStyle = PriceStyleEnum.psStandard;
break;
case "kagi":
priceStyle = PriceStyleEnum.psKagi;
_stockChartX.SetPriceStyleParam(0, 0); //Reversal size
_stockChartX.SetPriceStyleParam(1, (double)ChartDataType.Points);
break;
case "equivolume":
priceStyle = PriceStyleEnum.psEquiVolume;
break;
case "candlevolume":
priceStyle = PriceStyleEnum.psCandleVolume;
break;
case "equivolumeshadow":
priceStyle = PriceStyleEnum.psEquiVolumeShadow;
break;
case "pointandfigure":
priceStyle = PriceStyleEnum.psPointAndFigure;
_stockChartX.SetPriceStyleParam(0, 0); //Allow StockChartX to figure the box size
_stockChartX.SetPriceStyleParam(1, 3); //Reversal size
break;
case "renko":
priceStyle = PriceStyleEnum.psRenko;
_stockChartX.SetPriceStyleParam(0, 1); //Box size
break;
case "threelinebreak":
priceStyle = PriceStyleEnum.psThreeLineBreak;
_stockChartX.SetPriceStyleParam(0, 3); //Three line break (could be 1 to 50 line break)
break;
case "heikinashi":
priceStyle = PriceStyleEnum.psHeikinAshi;
break;
}
if (OHLCSeries != null && OHLCSeries.Length > 3)
{
OHLCSeries[0].SeriesType = seriesType;
OHLCSeries[1].SeriesType = seriesType;
OHLCSeries[2].SeriesType = seriesType;
OHLCSeries[3].SeriesType = seriesType;
}
_stockChartX.PriceStyle = priceStyle;
SetLinesSize(size);
_stockChartX.Update();
}
}
