Creating Your Own AddOn Window

1
/* This is where we define our AddOn window. The actual content is contained inside the tabs of the window defined in a custom class inheriting from NTTabPage.
2
    We must create a new window class which inherits from NTWindow for styling and implements the IWorkspacePersistence interface for the ability to save/restore from workspaces.*/
3
public class AddOnFrameworkWindow : NTWindow, IWorkspacePersistence
4
{
5
   public AddOnFrameworkWindow()
6
   {
7
       // set Caption property (not Title), since Title is managed internally to properly combine selected Tab Header and Caption for display in the windows taskbar
8
       // This is the name displayed in the top-left of the window
9
       Caption = "AddOn Framework";
10
 
11
       // Set the initial dimensions of the window
12
       Width   = 1085;
13
       Height = 900;
14
   }
15
} 

1
public class AddOnFrameworkWindow : NTWindow, IWorkspacePersistence
2
{
3
   public AddOnFrameworkWindow()
4
   {
5
       ...
6
 
7
       // TabControl should be created for window content if tab features are wanted
8
       TabControl tc = new TabControl();
9
 
10
       // Attached properties defined in **TabControlManager** class should be set to achieve tab moving, adding/removing tabs
11
       TabControlManager.SetIsMovable(tc, true);
12
       TabControlManager.SetCanAddTabs(tc, true);
13
       TabControlManager.SetCanRemoveTabs(tc, true);
14
 
15
       // if ability to add new tabs is desired, **TabControl** has to have attached property "Factory" set.
16
       TabControlManager.SetFactory(tc, new AddOnFrameworkWindowFactory());
17
         
18
       Content = tc;
19
   }
20
} 

1
/* Class which implements **Tools.INTTabFactory** must be created and set as an attached property for **TabControl**
2
in order to use tab page add/remove/move/duplicate functionality */
3
public class AddOnFrameworkWindowFactory : INTTabFactory
4
{
5
   // **INTTabFactory** member. Required to create parent window
6
   public NTWindow CreateParentWindow()
7
   {
8
       return new AddOnFrameworkWindow();
9
   }
10
 
11
   // **INTTabFactory** member. Required to create tabs
12
   public NTTabPage CreateTabPage(string typeName, bool isTrue)
13
   {
14
       return new NinjaTraderAddOnProject.AddOnPage();
15
   }
16
} 

1
/* This is where we define the actual content of the tabs for our AddOn window.
2
    Note: Class derived from **Tools.NTTabPage** has to be created if instrument link or interval link functionality is desired.
3
    **Tools.IInstrumentProvider** and/or **Tools.IIntervalProvider** interface(s) should be implemented.
4
    Also **NTTabPage** provides additional functionality for properly naming tab headers using properties and variables such as @FUNCTION, @INSTRUMENT, etc. */
5
public class AddOnFrameworkTab : NTTabPage, NinjaTrader.Gui.Tools.IInstrumentProvider, NinjaTrader.Gui.Tools.IIntervalProvider
6
{
7
   public AddOnFrameworkTab()
8
   {
9
       AddOnFrameworkWindowFactory myAddOnFrameworkWindowFactory = new AddOnFrameworkWindowFactory();
10
 
11
       Content = myAddOnFrameworkWindowFactory.CreateTabPage("AddOnPage",true);
12
   }
13
} 

1
public class AddOnFrameworkWindow : NTWindow, IWorkspacePersistence
2
{
3
   public AddOnFrameworkWindow()
4
   {
5
       ...
6
 
7
       /* In order to have link buttons functionality, tab control items must be derived from **Tools.NTTabPage**
8
       They can be added using extension method **AddNTTabPage(NTTabPage page)** */
9
       tc.AddNTTabPage(new **AddOnFrameworkTab**());
10
   }
11
} 

1
public class AddOnFrameworkWindow : NTWindow, IWorkspacePersistence
2
{
3
   public AddOnFrameworkWindow()
4
   {
5
       ...
6
 
7
       // **WorkspaceOptions** property must be set
8
       Loaded += (o, e) =>
9
       {
10
           if (WorkspaceOptions == null)
11
               WorkspaceOptions = new WorkspaceOptions("AddOnFramework-" + Guid.NewGuid().ToString("N"), this);
12
       };
13
   }
14
     
15
   // **IWorkspacePersistence** member. Required for restoring window from workspace
16
   public void Restore(XDocument document, XElement element)
17
   {
18
       if (MainTabControl != null)
19
           MainTabControl.RestoreFromXElement(element);
20
   }
21
 
22
   // **IWorkspacePersistence** member. Required for saving window to workspace
23
   public void Save(XDocument document, XElement element)
24
   {
25
       if (MainTabControl != null)
26
           MainTabControl.SaveToXElement(element);
27
   }
28
 
29
   // **IWorkspacePersistence** member
30
   public WorkspaceOptions WorkspaceOptions { get; set; }
31
} 

1
// Example of creating a two-column grid in C#
2
Grid grid = new Grid();
3
grid.Background = new SolidColorBrush(Colors.Transparent);
4
 
5
ColumnDefinition col1 = new ColumnDefinition();
6
col1.Width = new GridLength(55);
7
 
8
ColumnDefinition col2 = new ColumnDefinition();
9
col2.Width = new GridLength(45);
10
 
11
grid.ColumnDefinitions.Add(col1);
12
grid.ColumnDefinitions.Add(col2); 

1
// Will be called as a new NTWindow is created. It will be called in the thread of that window
2
protected override void OnWindowCreated(Window window)
3
{
4
     
5
   // We want to place our AddOn in the Control Center's menus
6
   ControlCenter cc = window as ControlCenter;
7
   if (cc == null)
8
       return;
9
 
10
   /* Determine we want to place our AddOn in the Control Center's "New" menu
11
    Other menus can be accessed via the control's "Automation ID". For example: toolsMenuItem, workspacesMenuItem, connectionsMenuItem, helpMenuItem. */
12
   NTMenuItem existingMenuItemInControlCenter = cc.FindFirst("ControlCenterMenuItemNew") as NTMenuItem;
13
   if (existingMenuItemInControlCenter == null)
14
       return;
15
 
16
   // 'Header' sets the name of our AddOn seen in the menu structure
17
   NTMenuItem addOnFrameworkMenuItem = new NTMenuItem { Header = "AddOn Framework", Style = Application.Current.TryFindResource("MainMenuItem") as Style };
18
 
19
   // Add our AddOn into the "New" menu
20
   existingMenuItemInControlCenter.Items.Add(addOnFrameworkMenuItem);
21
 
22
   // Subscribe to the event for when the user presses our AddOn's menu item
23
   addOnFrameworkMenuItem.Click += OnMenuItemClick;
24
}
25
 
26
// Open our AddOn's window when the menu item is clicked on
27
private void OnMenuItemClick(object sender, RoutedEventArgs e)
28
{
29
   Core.Globals.RandomDispatcher.BeginInvoke(new Action(() => new AddOnFrameworkWindow().Show()));
30
} 

1
// Will be called as a new NTWindow is destroyed. It will be called in the thread of that window
2
protected override void OnWindowDestroyed(Window window)
3
{
4
   if (addOnFrameworkMenuItem != null && window is ControlCenter)
5
   {
6
       if (existingMenuItemInControlCenter != null && existingMenuItemInControlCenter.Items.Contains(addOnFrameworkMenuItem))
7
           existingMenuItemInControlCenter.Items.Remove(addOnFrameworkMenuItem);
8
 
9
       addOnFrameworkMenuItem.Click -= OnMenuItemClick;
10
       addOnFrameworkMenuItem = null;
11
   }
12
} 

1
// Using the Instrument Selector
2
private InstrumentSelector instrumentSelector;
3
 
4
...
5
 
6
// Find instrument selector and attach event handler
7
instrumentSelector = LogicalTreeHelper.FindLogicalNode(pageContent, "instrumentSelector") as InstrumentSelector;
8
if (instrumentSelector != null)
9
   instrumentSelector.InstrumentChanged += OnInstrumentChanged; 

1
// Using the Interval Selector
2
private IntervalSelector intervalSelector;
3
 
4
...
5
 
6
// Find interval selector and attach event handler
7
intervalSelector = LogicalTreeHelper.FindLogicalNode(pageContent, "intervalSelector") as IntervalSelector;
8
if (intervalSelector != null)
9
   intervalSelector.IntervalChanged += OnIntervalChanged; 

1
// Using the Quantity Up/Down Selector
2
private QuantityUpDown qudSelector;
3
 
4
...
5
 
6
// Find Quantity selector
7
qudSelector = LogicalTreeHelper.FindLogicalNode(pageContent, "qudSelector") as QuantityUpDown; 

1
// Using the Time-in-Force Selector
2
private TifSelector tifSelector;
3
 
4
...
5
 
6
// Find TIF selector
7
tifSelector = LogicalTreeHelper.FindLogicalNode(pageContent, "tifSelector") as TifSelector;
8
 
9
// Be sure to bind our account selector to our TIF selector to ensure proper functionality
10
tifSelector.SetBinding(TifSelector.AccountProperty, new Binding { Source = accountSelector, Path = new PropertyPath("SelectedAccount") });
11
 
12
// When our TIF selector's selection changes
13
tifSelector.SelectionChanged += (o, args) =>
14
{
15
   // Change the selected TIF in the ATM strategy too
16
   if (atmStrategySelector.SelectedAtmStrategy != null)
17
   {
18
       atmStrategySelector.SelectedAtmStrategy.TimeInForce = tifSelector.SelectedTif;
19
   }
20
}; 

1
private AtmStrategy.AtmStrategySelector atmStrategySelector;
2
3
 
4
...
5
 
6
// Find ATM Strategy selector and attach event handler
7
atmStrategySelector = LogicalTreeHelper.FindLogicalNode(pageContent, "atmStrategySelector") as AtmStrategy.AtmStrategySelector;
8
atmStrategySelector.Id = Guid.NewGuid().ToString("N");
9
if (atmStrategySelector != null)
10
   atmStrategySelector.CustomPropertiesChanged += OnAtmCustomPropertiesChanged;
11
 
12
// Be sure to bind our account selector to our ATM strategy selector to ensure proper functionality
13
atmStrategySelector.SetBinding(AtmStrategy.AtmStrategySelector.AccountProperty, new Binding { Source = accountSelector, Path = new PropertyPath("SelectedAccount") });
14
 
15
// When our ATM selector's selection changes
16
atmStrategySelector.SelectionChanged += (o, args) =>
17
{
18
   if (atmStrategySelector.SelectedItem == null)
19
       return;
20
   if (args.AddedItems.Count > 0)
21
   {
22
       // Change the selected TIF in our TIF selector too
23
       NinjaTrader.NinjaScript.AtmStrategy selectedAtmStrategy = args.AddedItems[0] as NinjaTrader.NinjaScript.AtmStrategy;
24
       if (selectedAtmStrategy != null)
25
       {
26
           tifSelector.SelectedTif = selectedAtmStrategy.TimeInForce;
27
       }
28
   }
29
}; 

1
// **IInstrumentProvider** member. Required if you want to use the instrument link mechanism on this window.
2
public Cbi.Instrument Instrument
3
{
4
   get { return instrument; }
5
   set
6
   {
7
       // Send instrument to other windows linked to the same color
8
       PropagateInstrumentChange(value);
9
   }
10
} 

1
...
2
 
3
// Find an interval selector that we've added to our UI, and attach a custom event handler
4
intervalSelector = LogicalTreeHelper.FindLogicalNode(pageContent, "intervalSelector") as IntervalSelector;
5
if (intervalSelector != null)
6
   intervalSelector.IntervalChanged += OnIntervalChanged;
7
     
8
...
9
 
10
// This method is fired when our interval selector changes intervals
11
private void OnIntervalChanged(object sender, BarsPeriodEventArgs args)
12
{
13
   if (args.BarsPeriod == null)
14
       return;
15
 
16
   PropagateIntervalChange(args.BarsPeriod); 
17
}