protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Description = NinjaTrader.Custom.Resource.NinjaScriptIndicatorDescriptionRangeCounter;
Name = NinjaTrader.Custom.Resource.NinjaScriptIndicatorNameRangeCounter;
Calculate = Calculate.OnPriceChange;
CountDown = true;
DisplayInDataBox = false;
DrawOnPricePanel = false;
IsOverlay = true;
IsChartOnly = true;
IsOverlay = true;
IsSuspendedWhileInactive = true;
}
else if (State == State.Historical)
{
isAdvancedType = BarsPeriod.BarsPeriodType == BarsPeriodType.HeikenAshi || BarsPeriod.BarsPeriodType == BarsPeriodType.Volumetric;
bool isOtherType = BarsPeriod.ToString().IndexOf("Range") >= 0 || BarsPeriod.ToString().IndexOf(NinjaTrader.Custom.Resource.BarsPeriodTypeNameRange) >= 0;
if (BarsPeriod.BarsPeriodType == BarsPeriodType.Range ||
BarsPeriod.BaseBarsPeriodType == BarsPeriodType.Range && isAdvancedType ||
BarsArray[0].BarsType.BuiltFrom == BarsPeriodType.Tick && isOtherType)
{
supportsRange = true;
}
}
}
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Description = @"Universal renko bar type. Ported by Sim22, 2015. [email protected]";
Name = "UniRenko";
BarsPeriod = new BarsPeriod {
BarsPeriodType = (BarsPeriodType)501, BarsPeriodTypeName = "UniRenkoBarsType(501)", Value = 1
};
BuiltFrom = BarsPeriodType.Tick;
DaysToLoad = 3;
IsIntraday = true;
}
else if (State == State.Configure)
{
Properties.Remove(Properties.Find("BaseBarsPeriodType", true));
//Properties.Remove(Properties.Find("BaseBarsPeriodValue", true));
Properties.Remove(Properties.Find("PointAndFigurePriceType", true));
Properties.Remove(Properties.Find("ReversalType", true));
SetPropertyName("Value", "Tick Trend");
SetPropertyName("Value2", "Tick Reversal");
SetPropertyName("BaseBarsPeriodValue", "Open Offset");
Name = "UniR T" + BarsPeriod.Value + "R" + BarsPeriod.Value2; // +"O" + BarsPeriod.BaseBarsPeriodValue;
/// I kept the UI name short b/c as of NT8b6 the name space at the toolbar is very short. You would not see the values. Sim22.
}
}
// Es un evento que se ejecuta tipo One-Time cuando va de histórico hacia real-time
// Los estados pueden ser setup, processing data, to termination
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Name = "RenkoDavis";
BarsPeriod = new BarsPeriod {
BarsPeriodType = (BarsPeriodType)2018, BarsPeriodTypeName = "UniRenko (2018)", Value = 1
};
BuiltFrom = BarsPeriodType.Tick;
DaysToLoad = 3;
DefaultChartStyle = Gui.Chart.ChartStyleType.OpenClose;
IsIntraday = true;
IsTimeBased = false;
}
else if (State == State.Configure)
{
Name = string.Format(Core.Globals.GeneralOptions.CurrentCulture, Custom.Resource.DataBarsTypeRenko, BarsPeriod.Value);
Properties.Remove(Properties.Find("BaseBarsPeriodType", true));
Properties.Remove(Properties.Find("BaseBarsPeriodValue", true));
Properties.Remove(Properties.Find("PointAndFigurePriceType", true));
Properties.Remove(Properties.Find("ReversalType", true));
Properties.Remove(Properties.Find("Value2", true));
SetPropertyName("Value", Custom.Resource.NinjaScriptBarsTypeRenkoBrickSize);
}
}
public override void ApplyDefaultValue(BarsPeriod period)
{
//period.BarsPeriodTypeName = "UniRenko";
period.Value = 2;
period.Value2 = 6;
period.BaseBarsPeriodValue = 2;
}
public override void ApplyDefaultValue(BarsPeriod period)
{
period.BarsPeriodTypeName = displayName;
period.BaseBarsPeriodValue = 4; // rangeMax
period.Value = 4; // rangeMin
period.Value2 = 2; // openOption
}
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Name = Custom.Resource.NinjaScriptBarsTypeLineBreak;
BarsPeriod = new BarsPeriod {
BarsPeriodType = BarsPeriodType.LineBreak
};
DaysToLoad = 5;
DefaultChartStyle = Gui.Chart.ChartStyleType.OpenClose;
}
else if (State == State.Configure)
{
switch (BarsPeriod.BaseBarsPeriodType)
{
case BarsPeriodType.Minute: BuiltFrom = BarsPeriodType.Minute; IsIntraday = true; IsTimeBased = true; break;
case BarsPeriodType.Second: BuiltFrom = BarsPeriodType.Tick; IsIntraday = true; IsTimeBased = true; break;
case BarsPeriodType.Tick:
case BarsPeriodType.Volume: BuiltFrom = BarsPeriodType.Tick; IsIntraday = true; IsTimeBased = false; break;
default: BuiltFrom = BarsPeriodType.Day; IsIntraday = false; IsTimeBased = true; break;
}
switch (BarsPeriod.BaseBarsPeriodType)
{
case BarsPeriodType.Day: Name = string.Format("{0} {1} LineBreak{2}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.BaseBarsPeriodValue == 1 ? Resource.GuiDaily : Resource.GuiDay, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Minute: Name = string.Format("{0} Min LineBreak{1}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Month: Name = string.Format("{0} {1} LineBreak{2}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.BaseBarsPeriodValue == 1 ? Resource.GuiMonthly : Resource.GuiMonth, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Second: Name = string.Format("{0} {1} LineBreak{2}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.BaseBarsPeriodValue == 1 ? Resource.GuiSecond : Resource.GuiSeconds, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Tick: Name = string.Format("{0} Tick LineBreak{1}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Volume: Name = string.Format("{0} Volume LineBreak{1}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Week: Name = string.Format("{0} {1} LineBreak{2}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.BaseBarsPeriodValue == 1 ? Resource.GuiWeekly : Resource.GuiWeeks, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
case BarsPeriodType.Year: Name = string.Format("{0} {1} LineBreak{2}", BarsPeriod.BaseBarsPeriodValue, BarsPeriod.BaseBarsPeriodValue == 1 ? Resource.GuiYearly : Resource.GuiYears, BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", BarsPeriod.MarketDataType) : string.Empty); break;
}
Properties.Remove(Properties.Find("PointAndFigurePriceType", true));
Properties.Remove(Properties.Find("ReversalType", true));
Properties.Remove(Properties.Find("Value2", true));
SetPropertyName("Value", Custom.Resource.NinjaScriptBarsTypeLineBreakLineBreaks);
}
}
protected override void OnBarUpdate()
{
if (BarsInProgress != 0 || CurrentBar < BarsRequiredToTrade)
{
return;
}
////////////Instrument Variable Setting/////////
instrument = Instrument != null ? Instrument.FullName : "UndefInstrument";
fileDirectoryPath = ninjaDirectory + instrument;
barType = BarsPeriod.ToString();
barValue = BarsPeriod.Value.ToString();
daysLoaded = ChartBars.Properties.DaysBack;
strategyInfo = strategyInfo + "," + instrument + "," + barValue + "," + barType + "," + daysLoaded + "," + LookbackSetting + "," + LookbackSources + "," + SwingStrength + "," + VolOffSetCheck + "," + VolOffsetRatio;
instrumentType = instrument + "." + BarsPeriod.ToString();
pathCSV = fileDirectoryPath + "/" + instrumentType + daysLoaded + "days" + "." + LookbackSources + LookbackSetting + SwingStrength + "ss" + VolOffsetRatio + "volr" + "." + fileName; // Define the Path to our test file
if (!Directory.Exists(fileDirectoryPath))
{
Directory.CreateDirectory(fileDirectoryPath);
}
////////////Data Variable Setting////////////
dataIndex = (CurrentBar - 1);
ntStockData = CurrentBar + "," + Time[0] + "," + Open[0] + "," + High[0] + "," + Low[0] + "," + Close[0];
auroraStockData = indiTachAur.TrendPlot.GetValueAt(dataIndex) + "," + indiTachAur.BarsToNextSignal.GetValueAt(dataIndex) + "," + indiTachAur.BarsFromPreviousSignal.GetValueAt(dataIndex) + "," + indiTachAur.SignalPattern.GetValueAt(dataIndex) + "," + indiTachAur.BuySignalStopLine.GetValueAt(dataIndex) + "," + indiTachAur.SellSignalStopLine.GetValueAt(dataIndex) + "," + indiTachAur.DotPrice.GetValueAt(dataIndex) + "," + indiTachAur.OpenPrice.GetValueAt(dataIndex);
fullPrintOut = ntStockData + "," + auroraStockData;
////////////Printing area////////////
if (!File.Exists(pathCSV))
{
sw = File.AppendText(pathCSV);
sw.WriteLine(strategyLabels);
sw.WriteLine(strategyInfo);
sw.WriteLine(labels);
sw.Close();
}
else
{
Print("string.Format(fullPrintOut)");
Print(string.Format(fullPrintOut));
sw = File.AppendText(pathCSV);
sw.WriteLine(fullPrintOut); // Append a new line to the file
sw.Close(); // Close the file to allow future calls to access the file again.
}
}
public override int GetInitialLookBackDays(BarsPeriod barsPeriod, TradingHours tradingHours, int barsBack)
{
int minutesPerWeek = 0;
lock (tradingHours.Sessions)
{
foreach (Session session in tradingHours.Sessions)
{
int beginDay = (int)session.BeginDay;
int endDay = (int)session.EndDay;
if (beginDay > endDay)
{
endDay += 7;
}
minutesPerWeek += (endDay - beginDay) * 1440 + ((session.EndTime / 100) * 60 + (session.EndTime % 100)) - ((session.BeginTime / 100) * 60 + (session.BeginTime % 100));
}
}
return((int)Math.Max(1, Math.Ceiling(barsBack / Math.Max(1, minutesPerWeek / 7.0 / barsPeriod.Value) * 1.05)));
}
public override void ApplyDefaultBasePeriodValue(BarsPeriod period)
{
switch (period.BaseBarsPeriodType)
{
case BarsPeriodType.Day: period.BaseBarsPeriodValue = 1; DaysToLoad = 365; break;
case BarsPeriodType.Minute: period.BaseBarsPeriodValue = 1; DaysToLoad = 5; break;
case BarsPeriodType.Month: period.BaseBarsPeriodValue = 1; DaysToLoad = 5475; break;
case BarsPeriodType.Second: period.BaseBarsPeriodValue = 30; DaysToLoad = 3; break;
case BarsPeriodType.Tick: period.BaseBarsPeriodValue = 150; DaysToLoad = 3; break;
case BarsPeriodType.Volume: period.BaseBarsPeriodValue = 1000; DaysToLoad = 3; break;
case BarsPeriodType.Week: period.BaseBarsPeriodValue = 1; DaysToLoad = 1825; break;
case BarsPeriodType.Year: period.BaseBarsPeriodValue = 1; DaysToLoad = 15000; break;
}
}
public override int GetInitialLookBackDays(BarsPeriod barsPeriod, TradingHours tradingHours, int barsBack)
{
switch (BarsPeriod.BaseBarsPeriodType)
{
case BarsPeriodType.Day: return((int)Math.Ceiling(barsPeriod.BaseBarsPeriodValue * barsBack * 7.0 / 4.5));
case BarsPeriodType.Minute:
int minutesPerWeek = 0;
lock (tradingHours.Sessions)
{
foreach (Session session in tradingHours.Sessions)
{
int beginDay = (int)session.BeginDay;
int endDay = (int)session.EndDay;
if (beginDay > endDay)
{
endDay += 7;
}
minutesPerWeek += (endDay - beginDay) * 1440 + session.EndTime / 100 * 60 + session.EndTime % 100 - (session.BeginTime / 100 * 60 + session.BeginTime % 100);
}
}
return((int)Math.Max(1, Math.Ceiling(barsBack / Math.Max(1, minutesPerWeek / 7.0 / barsPeriod.BaseBarsPeriodValue) * 1.05)));
case BarsPeriodType.Month: return(barsPeriod.BaseBarsPeriodValue * barsBack * 31);
case BarsPeriodType.Second: return((int)Math.Max(1, Math.Ceiling(barsBack / Math.Max(1, 8.0 * 60 * 60 / barsPeriod.BaseBarsPeriodValue)) * 7.0 / 5.0)); // 8 hours
case BarsPeriodType.Tick: return(1);
case BarsPeriodType.Volume: return(1);
case BarsPeriodType.Week: return(barsPeriod.BaseBarsPeriodValue * barsBack * 7);
case BarsPeriodType.Year: return(barsPeriod.BaseBarsPeriodValue * barsBack * 365);
default: return(1);
}
}
public override int GetInitialLookBackDays(BarsPeriod barsPeriod, TradingHours tradingHours, int barsBack)
{
switch (BarsPeriod.BaseBarsPeriodType)
{
case BarsPeriodType.Day: return(new DayBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Minute: return(new MinuteBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Month: return(new MonthBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Second: return(new SecondBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Tick: return(new TickBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Volume: return(new VolumeBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Week: return(new WeekBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
case BarsPeriodType.Year: return(new YearBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
default: return(new MinuteBarsType().GetInitialLookBackDays(barsPeriod, tradingHours, barsBack));
}
}
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Name = Custom.Resource.NinjaScriptBarsTypeSecond;
BarsPeriod = new BarsPeriod {
BarsPeriodType = BarsPeriodType.Second
};
BuiltFrom = BarsPeriodType.Tick;
DaysToLoad = 3;
IsIntraday = true;
IsTimeBased = true;
}
else if (State == State.Configure)
{
Name = string.Format("{0}{1}", string.Format(Core.Globals.GeneralOptions.CurrentCulture, Custom.Resource.DataBarsTypeSecond, BarsPeriod.Value), BarsPeriod.MarketDataType != MarketDataType.Last ? string.Format(" - {0}", Core.Globals.ToLocalizedObject(BarsPeriod.MarketDataType, Core.Globals.GeneralOptions.CurrentUICulture)) : string.Empty);
Properties.Remove(Properties.Find("BaseBarsPeriodType", true));
Properties.Remove(Properties.Find("BaseBarsPeriodValue", true));
Properties.Remove(Properties.Find("PointAndFigurePriceType", true));
Properties.Remove(Properties.Find("ReversalType", true));
Properties.Remove(Properties.Find("Value2", true));
}
}
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Name = displayName;
Description = @"Momentum Bars Type is a variant of the Range Bar with a fixed or dynamic height candle body (open-close) configured by RangeMax, RangeMin, and OpenOption.";
BarsPeriod = new BarsPeriod {
BarsPeriodType = (BarsPeriodType)42, BarsPeriodTypeName = "MomentumBars", Value = 4, BaseBarsPeriodValue = 4, Value2 = 2
};
BuiltFrom = BarsPeriodType.Tick;
DaysToLoad = 5;
IsIntraday = true;
IsTimeBased = false;
}
else if (State == State.Configure)
{
// remove properties not needed for this bar type
Properties.Remove(Properties.Find("BaseBarsPeriodType", true));
Properties.Remove(Properties.Find("PointAndFigurePriceType", true));
Properties.Remove(Properties.Find("ReversalType", true));
// set display labels
SetPropertyName("Value", "Range Min");
SetPropertyName("BaseBarsPeriodValue", "Range Max");
SetPropertyName("Value2", "1=NoGap; 2=TrueOpen");
// swap min/max if entered incorrectly
int tmpMin = this.BarsPeriod.Value;
int tmpMax = this.BarsPeriod.BaseBarsPeriodValue;
if (tmpMin > tmpMax)
{
this.BarsPeriod.Value = tmpMax;
this.BarsPeriod.BaseBarsPeriodValue = tmpMin;
}
}
}
public override int GetInitialLookBackDays(BarsPeriod period, TradingHours tradingHours, int barsBack)
{
return((int)Math.Max(1, Math.Ceiling(barsBack / Math.Max(1, 8.0 * 60 * 60 / period.Value)) * 7.0 / 5.0));
}
public override void ApplyDefaultValue(BarsPeriod period)
{
period.Value = 30;
}
public override void ApplyDefaultBasePeriodValue(BarsPeriod period)
{
}
protected override void OnStateChange()
{
if (State == State.SetDefaults)
{
Name = "Num Touches";
Buys = new ConcurrentDictionary <double, long>();
BackColor = Brushes.Transparent;
BarColor = Application.Current.TryFindResource("brushVolumeColumnBackground") as Brush;
BuyColor = Brushes.Green;
DefaultWidth = 160;
PreviousWidth = -1;
DisplayText = true;
ForeColor = Application.Current.TryFindResource("brushVolumeColumnForeground") as Brush;
ImmutableBarColor = Application.Current.TryFindResource("immutableBrushVolumeColumnBackground") as Brush;
ImmutableForeColor = Application.Current.TryFindResource("immutableBrushVolumeColumnForeground") as Brush;
IsDataSeriesRequired = true;
LastVolumes = new ConcurrentDictionary <double, long>();
SellColor = Brushes.Red;
Sells = new ConcurrentDictionary <double, long>();
Bidask = VolumeSide.bid;
}
else if (State == State.Configure)
{
if (UiWrapper != null && PresentationSource.FromVisual(UiWrapper) != null)
{
Matrix m = PresentationSource.FromVisual(UiWrapper).CompositionTarget.TransformToDevice;
double dpiFactor = 1 / m.M11;
gridPen = new Pen(Application.Current.TryFindResource("BorderThinBrush") as Brush, 1 * dpiFactor);
halfPenWidth = gridPen.Thickness * 0.5;
}
if (SuperDom.Instrument != null && SuperDom.IsConnected)
{
BarsPeriod bp = new BarsPeriod
{
MarketDataType = MarketDataType.Last,
BarsPeriodType = BarsPeriodType.Tick,
Value = 1
};
SuperDom.Dispatcher.InvokeAsync(() => SuperDom.SetLoadingString());
clearLoadingSent = false;
if (BarsRequest != null)
{
BarsRequest.Update -= OnBarsUpdate;
BarsRequest = null;
}
BarsRequest = new BarsRequest(SuperDom.Instrument,
Cbi.Connection.PlaybackConnection != null ? Cbi.Connection.PlaybackConnection.Now : Core.Globals.Now,
Cbi.Connection.PlaybackConnection != null ? Cbi.Connection.PlaybackConnection.Now : Core.Globals.Now);
BarsRequest.BarsPeriod = bp;
BarsRequest.TradingHours = (TradingHoursData == TradingHours.UseInstrumentSettings || TradingHours.Get(TradingHoursData) == null) ? SuperDom.Instrument.MasterInstrument.TradingHours : TradingHours.Get(TradingHoursData);
BarsRequest.Update += OnBarsUpdate;
BarsRequest.Request((request, errorCode, errorMessage) =>
{
// Make sure this isn't a bars callback from another column instance
if (request != BarsRequest)
{
return;
}
lastMaxIndex = 0;
maxVolume = 0;
totalBuyVolume = 0;
totalLastVolume = 0;
totalSellVolume = 0;
Sells.Clear();
Buys.Clear();
LastVolumes.Clear();
if (State >= NinjaTrader.NinjaScript.State.Terminated)
{
return;
}
if (errorCode == Cbi.ErrorCode.UserAbort)
{
if (State <= NinjaTrader.NinjaScript.State.Terminated)
{
if (SuperDom != null && !clearLoadingSent)
{
SuperDom.Dispatcher.InvokeAsync(() => SuperDom.ClearLoadingString());
clearLoadingSent = true;
}
}
request.Update -= OnBarsUpdate;
request.Dispose();
request = null;
return;
}
if (errorCode != Cbi.ErrorCode.NoError)
{
request.Update -= OnBarsUpdate;
request.Dispose();
request = null;
if (SuperDom != null && !clearLoadingSent)
{
SuperDom.Dispatcher.InvokeAsync(() => SuperDom.ClearLoadingString());
clearLoadingSent = true;
}
}
else if (errorCode == Cbi.ErrorCode.NoError)
{
SessionIterator superDomSessionIt = new SessionIterator(request.Bars);
bool isInclude60 = request.Bars.BarsType.IncludesEndTimeStamp(false);
if (superDomSessionIt.IsInSession(Core.Globals.Now, isInclude60, request.Bars.BarsType.IsIntraday))
{
for (int i = 0; i < request.Bars.Count; i++)
{
DateTime time = request.Bars.BarsSeries.GetTime(i);
if ((isInclude60 && time <= superDomSessionIt.ActualSessionBegin) || (!isInclude60 && time < superDomSessionIt.ActualSessionBegin))
{
continue;
}
double ask = request.Bars.BarsSeries.GetAsk(i);
double bid = request.Bars.BarsSeries.GetBid(i);
double close = request.Bars.BarsSeries.GetClose(i);
long volume = request.Bars.BarsSeries.GetVolume(i);
if (ask != double.MinValue && close >= ask)
{
Buys.AddOrUpdate(close, volume, (price, oldVolume) => oldVolume + volume);
totalBuyVolume += volume;
}
else if (bid != double.MinValue && close <= bid)
{
Sells.AddOrUpdate(close, volume, (price, oldVolume) => oldVolume + volume);
totalSellVolume += volume;
}
long newVolume;
LastVolumes.AddOrUpdate(close, newVolume = volume, (price, oldVolume) => newVolume = 0);
totalLastVolume += volume;
if (newVolume > maxVolume)
{
maxVolume = newVolume;
}
}
lastMaxIndex = request.Bars.Count - 1;
// Repaint the column on the SuperDOM
OnPropertyChanged();
}
if (SuperDom != null && !clearLoadingSent)
{
SuperDom.Dispatcher.InvokeAsync(() => SuperDom.ClearLoadingString());
clearLoadingSent = true;
}
}
});
}
}
else if (State == State.Active)
{
if (!DisplayText)
{
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .AddHandler(UiWrapper, "MouseMove", OnMouseMove);
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .AddHandler(UiWrapper, "MouseEnter", OnMouseEnter);
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .AddHandler(UiWrapper, "MouseLeave", OnMouseLeave);
mouseEventsSubscribed = true;
}
}
else if (State == State.Terminated)
{
if (BarsRequest != null)
{
BarsRequest.Update -= OnBarsUpdate;
BarsRequest.Dispose();
}
BarsRequest = null;
if (SuperDom != null && !clearLoadingSent)
{
SuperDom.Dispatcher.InvokeAsync(() => SuperDom.ClearLoadingString());
clearLoadingSent = true;
}
if (!DisplayText && mouseEventsSubscribed)
{
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .RemoveHandler(UiWrapper, "MouseMove", OnMouseMove);
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .RemoveHandler(UiWrapper, "MouseEnter", OnMouseEnter);
WeakEventManager <System.Windows.Controls.Panel, MouseEventArgs> .RemoveHandler(UiWrapper, "MouseLeave", OnMouseLeave);
mouseEventsSubscribed = false;
}
lastMaxIndex = 0;
maxVolume = 0;
totalBuyVolume = 0;
totalLastVolume = 0;
totalSellVolume = 0;
Sells.Clear();
Buys.Clear();
LastVolumes.Clear();
}
}
public override int GetInitialLookBackDays(BarsPeriod barsPeriod, TradingHours tradingHours, int barsBack)
{
return((int)Math.Ceiling(barsPeriod.Value * barsBack * 7.0 / 4.5));
}
public override int GetInitialLookBackDays(BarsPeriod barsPeriod, TradingHours tradingHours, int barsBack)
{
return(barsPeriod.Value * barsBack * 365);
}
public override int GetInitialLookBackDays(BarsPeriod period, TradingHours tradingHours, int barsBack)
{
return(3);
}
protected override void OnStateChange()
{
switch (State)
{
case State.SetDefaults:
{
Name = "Renet";
Description = "Time master";
Calculate = Calculate.OnEachTick;
IsOverlay = true;
AddPlot(Brushes.Black, "Globex Close");
ZOrder = int.MinValue;
break;
}
case State.Configure:
{
try
{
AddDataSeries(Instrument.FullName, new BarsPeriod
{
BarsPeriodType = BarsPeriodType.Minute,
Value = 1440
}, "CME US Index Futures RTH");
}
catch
{
AddDataSeries("ES ##-##", new BarsPeriod
{
BarsPeriodType = BarsPeriodType.Minute,
Value = 1440
}, "CME US Index Futures RTH");
}
finally
{
}
break;
}
case State.Historical:
{
sessionIterator = new SessionIterator(BarsArray[1]);
if (ChartControl != null)
{
// set the shade for first 30 minutes by cloning a visible version of the user configured background brush
first30MinuteBrush = (Utilities.CalculateVisibleColor(ChartControl.Properties.ChartBackground) as Brush).Clone();
first30MinuteBrush.Opacity = .10f;
first30MinuteBrush.Freeze();
}
// used variously to prevent some actions on bigger time frames
BarsPeriod inputPeriod = BarsArray[0].BarsPeriod;
if (inputPeriod != null &&
(inputPeriod.BarsPeriodType == (BarsPeriodType.Day) ||
(inputPeriod.BarsPeriodType == BarsPeriodType.Minute && inputPeriod.Value >= 60)))
{
isHigherTimeFrame = true;
}
break;
}
case State.Terminated:
{ break; }
case State.Undefined:
{ break; }
case State.Active:
{ break; }
case State.DataLoaded:
{ break; }
case State.Transition:
{ break; }
case State.Realtime:
{ break; }
case State.Finalized:
{ break; }
default:
{
throw new Exception(string.Format("Unhandled State={0}", State));
}
}
}
