Other Uses for an AddOn

Modifying Existing NinjaTrader Windows

To modify an existing type of NinjaTrader window (for example, to add a button to all charts), you will first need to obtain a reference to each individual window of that type that is open. This can be done by overriding the OnWindowCreated() method, then declaring an object of the Type of the window you are looking for, and finally assigning the object a reference to the Window passed into the method:

1 // OnWindowCreated() will be called any time a new NTWindow is created. It will be called in the thread of that window
2 protected override void OnWindowCreated(Window window)
3 {
4    // Declare a Chart object and instantiate it to the Window passed into the method
5    Gui.Chart.Chart myChart = window as Gui.Chart.Chart;
6     
7    // Use this check to return if the calling Window is not of the Type you are looking for
8    if (myChart == null)
9        return;
10 }

If you are unsure of the Type name for a particular type of window, you can open an instance of that window then run the code below, which will print the Type to the Output Window:

1 protected override void OnWindowCreated(Window window)
2 {
3    // Print the Type of any open windows, for future reference
4    Print(window.ToString());
5 }

Once you’ve obtained a reference to a window, you can then directly manipulate the WPF grids, controls, and other elements to customize its user interface or functionality. For example, if your goal was to add a new button to Chart Trader on all charts, you could use your reference to Chart objects to first locate their attached Chart Trader instances, then place a custom-defined button directly into the WPF grid used to lay out buttons in Chart Trader. Since this code would run within OnWindowCreated(), it would be applied to every Chart Trader instance that is open. You would not be changing the format used to create Chart Traders in the first place, but would rather be detecting every open instance and adding the buttons into them. This is an important distinction to make, because this approach requires that you also remove the elements you’ve added when each window is destroyed.

1 // Declare a Chart, ChartTrader, and UI elements to add to Chart Trader
2 Gui.Chart.Chart myChart;
3 Gui.Chart.ChartTrader chartTrader;
4 Button sampleButton;
5 Grid myGrid;
6 Grid mainGrid;
7  
8 protected override void OnWindowCreated(Window window)
9 {
10    // Instantiate myChart by assigning a reference to the calling Window
11    myChart = window as Gui.Chart.Chart;
12  
13    if (myChart == null)
14    {
15        return;
16    }
17  
18    //find chart trader from myChart's Chart Control by its Automation ID: "ChartWindowChartTrader"
19    chartTrader = Window.GetWindow(myChart.ActiveChartControl.Parent).FindFirst("ChartWindowChartTraderControl") as Gui.Chart.ChartTrader;
20  
21    if (chartTrader == null)
22    {
23        return;
24    }
25  
26    // Instantiate sampleButton
27    sampleButton = new Button
28    {
29        Content = "Sample Button",
30        Style = System.Windows.Application.Current.TryFindResource("Button") as Style
31    };
32  
33    // Attach a custom event handler to the .Click event
34    sampleButton.Click += SampleButton_Click;
35  
36    // Set a custom AutomationId for the button, so that it can be referenced elsewhere the same way we found Chart Trader
37    System.Windows.Automation.AutomationProperties.SetAutomationId(sampleButton, "SampleButton");
38  
39    //this is the main chart trader grid where the default buttons and controls reside
40    mainGrid = chartTrader.FindName("grdMain") as Grid;
41  
42    // Return if Chart Trader is null
43    if (mainGrid == null)
44    {
45        return;
46    }
47  
48    // by default, there will be 7 rows in Chart Trader, we need to add a new row for the new button
49    if (mainGrid.RowDefinitions.Count <= 7)
50        mainGrid.RowDefinitions.Add(new RowDefinition());
51  
52    //define a new grid, and add our button to that grid
53    myGrid = new Grid();
54    myGrid.Children.Add(sampleButton);
55  
56    //set my grid to the new row 
57    Grid.SetRow(myGrid, 8);
58  
59    //finally, add our grid to the main grid
60    mainGrid.Children.Add(myGrid);
61 }
62  
63 private void SampleButton_Click(object sender, RoutedEventArgs e)
64 {
65    Print("Sample Button Clicked");
66 }

Since we are dynamically adding elements to open windows, it is important to clean up any unused resources and detach any event handlers when the affected windows are destroyed. You can use the same approach as shown above to obtain a reference to each affected window within the OnWindowDestroyed() method:

1 protected override void OnWindowDestroyed(Window window)
2 {
3    // Return if there is no button, or if the destroyed window is not a chart
4    if(sampleButton == null || !(window is Gui.Chart.Chart))
5    {
6        return;
7    }
8  
9    // Detach the event handler from the .Click event, remove the grid, and nullify the button
10    sampleButton.Click -= SampleButton_Click;
11    mainGrid.Children.Remove(myGrid);
12    sampleButton = null;
13 }

Below is another example of adding elements into chart windows. In this example, we add a new panel to the top of all chart windows, then take all existing chart content and move it into a row beneath the panel we’ve just added:

1 protected override void OnWindowCreated(Window window)
2 {
3    // Obtain a reference to any chart that triggered OnWindowCreated
4    Chart Window = window as Chart;
5     
6    // Instantiate a grid to hold a reference to the content of the chart window
7    Grid mainWindowGrid = Window.Content as Grid;
8     
9    // Add existing row definition for existing row if it is not present
10    if (mainWindowGrid.RowDefinitions.Count == 0)
11    {
12        mainWindowGrid.RowDefinitions.Add(new RowDefinition());
13    }
14                 
15    // Instantiate a RowDefinition and set its height
16    RowDefinition row = new RowDefinition();
17    row.Height = new GridLength(PanelLength);
18     
19    // Insert the new row into the chart's main window grid
20    mainWindowGrid.RowDefinitions.Insert(0, row);
21     
22    //Move Existing Elements down one row, since our new content will take the top row
23    foreach (UIElement element in mainWindowGrid.Children)
24    {
25        element.SetValue(Grid.RowProperty, (int)element.GetValue(Grid.RowProperty) + 1);
26    }
27     
28    //Create the Top Panel grid and add it to our newly defined row
29    Grid Panel = new Grid();
30    Panel.SetValue(Grid.RowProperty, 0);
31    mainWindowGrid.Children.Add(Panel);
32  
33    //Create a sample text block and add it to the Top/Bottom Panel Grid.
34    TextBlock TextBlock = new TextBlock();
35    TextBlock.Text = PanelDirection.ToString() + " Panel (" + PanelLocation.ToString() + ") Sample Text Block";
36    TextBlock.Foreground = Brushes.Red;
37    TextBlock.SetValue(Grid.RowProperty, 0);
38    Panel.Children.Add(TextBlock);
39 }

Accessing Account Data

From time to time, you may need to access certain global data, such as account values, order states, position info, etc. In these cases, you can subscribe to an appropriate event using a custom event handler method. Below is a list of a few such events which can be captured:

Method
Description

<account>.AccountItemUpdate
Triggers on account item updates

<account>.ExecutionUpdate
Triggers on any execution

<account>.OrderUpdate
Triggers on any order state changes

<account>.PositionUpdate
Triggers on any position updates

1 // Custom Subscribe() method to refresh subscriptions
2 private void Subscribe()
3 {
4    if (myAccount != null)
5    {
6        // Unsubscribe to any prior account subscriptions
7        myAccount.AccountItemUpdate -= OnAccountItemUpdate;
8        myAccount.ExecutionUpdate -= OnExecutionUpdate;
9        myAccount.OrderUpdate -= OnOrderUpdate;
10        myAccount.PositionUpdate -= OnPositionUpdate;
11  
12        // Subscribe to new account subscriptions
13        myAccount.AccountItemUpdate   += OnAccountItemUpdate;
14        myAccount.ExecutionUpdate     += OnExecutionUpdate;
15        myAccount.OrderUpdate         += OnOrderUpdate;
16        myAccount.PositionUpdate     += OnPositionUpdate;
17    }
18 }
19  
20 private void OnAccountItemUpdate(object sender, AccountItemEventArgs e)
21 {
22    // Handle account item updates
23 }
24  
25 private void OnExecutionUpdate(object sender, AccountItemEventArgs e)
26 {
27    // Handle execution updates
28 }
29  
30 private void OnOrderUpdate(object sender, AccountItemEventArgs e)
31 {
32    // Handle order updates
33 }
34  
35 private void OnPositionUpdate(object sender, AccountItemEventArgs e)
36 {
37    // Handle position updates
38 }

Accessing Market Data

Market data can be accessed via a BarsRequest object, which can provide real-time or snapshot data for use by your classes. A BarsRequest object can be loaded with a series of bar data without the need to actually draw bars on a chart. The BarsRequest object can then be accessed via the BarsUpdateEventArgs object passed into your event handler via the BarsRequest’s Update method. The process for using a BarsRequest is as follows:

Instantiate an Instrument object
Instantiate and parameterize a BarsRequest object
Hook the BarsRequest’s Update event to a custom event handler
Call the BarsRequest’s Request() method
Access bars data directly from the BarsRequest object within your event handler method

1 // Custom method to perform a BarsRequest
2 private NinjaTrader.Data.BarsRequest DoBarsRequest(Instrument instrument, int lookBackPeriod)
3 {
4    // Declare a BarsRequest object
5    NinjaTrader.Data.BarsRequest barsRequest;
6     
7    // Request x number of days back of data.
8    barsRequest = new NinjaTrader.Data.BarsRequest(instrument, DateTime.Now.AddDays(-lookBackPeriod), DateTime.Now);
9  
10    // If you wish to request x number of bars back instead you can use this signature:
11    // barsRequest = new NinjaTrader.Data.BarsRequest(instrument, lookBackPeriod);
12     
13  
14    // Parameterize the request
15    barsRequest.BarsPeriod = new NinjaTrader.Data.BarsPeriod { BarsPeriodType = BarsPeriodType.Minute, Value = 60 };
16    barsRequest.TradingHours     = NinjaTrader.Data.TradingHours.Get("Default 24 x 7");
17     
18    // Additional parameters which could be set
19    // barsRequest.IsDividendAdjusted      = true;
20    // barsRequest.IsResetOnNewTradingDay   = false;
21    // barsRequest.IsSplitAdjusted         = true;
22    // barsRequest.LookupPolicy            = LookupPolicies.Provider;
23    // barsRequest.MergePolicy            = MergePolicy.DoNotMerge;
24  
25    // Attach event handler for real-time events if you want to process real-time data
26    barsRequest.Update     += MyOnBarUpdate;
27     
28    // Call the Request method on the BarsRequest object to request the bars
29    barsRequest.Request(new Action<ninjatrader.data.barsrequest, errorcode,="" string="">((bars, errorCode, errorMessage) =>
30    {
31        Dispatcher.InvokeAsync(new Action(() =>
32        {
33            if (errorCode != ErrorCode.NoError)
34            {
35                // Handle any errors in requesting bars here
36                outputBox.Text = string.Format("Error on requesting bars: {0}, {1}", errorCode, errorMessage);
37                return;
38            }
39        }));
40    }));
41     
42    // Return the Bars Request to any callers of this method
43    return barsRequest;
44 }
45  
46 // BarsUpdateEventArgs is provided by the BarsRequest's Update event
47 private void MyOnBarUpdate(object sender, NinjaTrader.Data.BarsUpdateEventArgs e)
48 {
49    /* Dispatcher.InvokeAsync() is needed for multi-threading considerations. When processing events outside of the UI thread, and we want to
50     influence the UI .InvokeAsync() allows us to do so. It can also help prevent the UI thread from locking up on long operations. */
51    Dispatcher.InvokeAsync(() =>
52    {
53        /* Depending on the BarsPeriod type of your barsRequest you can have situations where more than one bar is updated by a single tick
54         Be sure to process the full range of updated bars to ensure you did not miss a bar. */
55  
56        // Process updated bars on each tick
57        for (int i = e.MinIndex; i <= e.MaxIndex; i++)
58        {
59            // Processing every single tick
60            outputBox.Text = string.Format("REALTIME BARS{0}Time: {1}{0}Open: {2}{0}High: {3}{0}Low: {4}{0}Close: {5}",
61                Environment.NewLine,
62                e.BarsSeries.GetTime(i),
63                e.BarsSeries.GetOpen(i),
64                e.BarsSeries.GetHigh(i),
65                e.BarsSeries.GetLow(i),
66                e.BarsSeries.GetClose(i));
67        }
68    });
69 }