---
id: "T:cAlgo.API.ChartTemplates"
kind: "interface"
namespace: "cAlgo.API"
url: "https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/"
---

> Documentation index for agents: https://help.ctrader.com/ctrader-algo/llms.txt · machine index: https://help.ctrader.com/ctrader-algo/api.json

# ChartTemplates (interface)

Represents collection of chart templates and provide access to chart template API.

Environments: Desktop supported · CLI works differently · Cloud not supported.

- CLI: No templates are listed; Create works for this run only and is not saved; Remove returns false; DefaultTemplate throws NullReferenceException.
- Cloud: Empty: Get returns null, Contains and Remove return false, Create and Duplicate throw, DefaultTemplate throws NullReferenceException.

## Definition

```csharp
public interface ChartTemplates
```

Available since cAlgo.API 5.6.

## Examples

C#:

```csharp
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Linq;

namespace cAlgo.Robots
{
    public partial class ChartTemplatesTest : Robot
    {
        protected override void OnStart()
        {
            var templatesComboBox = new ComboBox();

            foreach (var template in ChartTemplates)
            {
                templatesComboBox.AddItem(template.Name);
            }

            ChartTemplates.Added += args =>
            {
                templatesComboBox.AddItem(args.ChartTemplate.Name);
                Print($"New Template added: {args.ChartTemplate.Name}");
            };

            ChartTemplates.Removed += args =>
            {
                templatesComboBox.RemoveItem(args.ChartTemplate.Name);
                Print($"Template Removed: {args.ChartTemplate.Name}");
            };

            var showTemplateInfoButton = new Button {Text = "Show Template Info"};

            showTemplateInfoButton.Click += args =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                Print($"Name: {template.Name} | Bots #: {template.Robots.Count} | Indicators #: {template.Indicators.Count}");
            };

            var showDefaultTemplateInfoButton = new Button {Text = "Show Default Template Info"};

            showDefaultTemplateInfoButton.Click += args =>
            {
                Print($"Name: {ChartTemplates.DefaultTemplate.Name} | Bots #: {ChartTemplates.DefaultTemplate.Robots.Count} | Indicators #: {ChartTemplates.DefaultTemplate.Indicators.Count}");
            };

            var removeTemplateButton = new Button {Text = "Remove Template"};

            removeTemplateButton.Click += _ => ChartTemplates.Remove(ChartTemplates.Get(templatesComboBox.SelectedItem));

            var applyTemplateButton = new Button {Text = "Apply Template"};

            applyTemplateButton.Click += _ => ChartTemplates.Get(templatesComboBox.SelectedItem).Apply(Chart);

            var duplicateTemplateButton = new Button {Text = "Duplicate Template"};

            duplicateTemplateButton.Click += _ => ChartTemplates.Duplicate($"{templatesComboBox.SelectedItem} Duplicate", ChartTemplates.Get(templatesComboBox.SelectedItem));

            var createTemplateTextBox = new TextBox {Text = "Template Name"};

            var createEmptyTemplateButton = new Button {Text = "Create Empty Template"};

            createEmptyTemplateButton.Click += _ => ChartTemplates.Create(createTemplateTextBox.Text);

            var createTemplateBasedOnChartButton = new Button {Text = "Create Template Based On Chart"};

            createTemplateBasedOnChartButton.Click += _ => ChartTemplates.Create(createTemplateTextBox.Text, Chart);

            var changeDefaultTemplateToSelectedButton = new Button {Text = "Change Default Template To Selected"};

            changeDefaultTemplateToSelectedButton.Click += _ => ChartTemplates.DefaultTemplate = ChartTemplates.Get(templatesComboBox.SelectedItem);

            var checkSelectedTemplateExistsButton = new Button {Text = "Check Selected Template Exists"};

            checkSelectedTemplateExistsButton.Click += _ => Print($"Template {templatesComboBox.SelectedItem} Exists: {ChartTemplates.Contains(templatesComboBox.SelectedItem)}");

            var removeSelectedTemplateIndicator = new Button {Text = "Remove Selected Template Indicator"};

            removeSelectedTemplateIndicator.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (template.Indicators.Count == 0)
                    return;

                Print($"Remove Result: {template.Indicators.Remove(template.Indicators.First())}");
            };

            var removeSelectedTemplateBot = new Button {Text = "Remove Selected Template Bot"};

            removeSelectedTemplateBot.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (template.Robots.Count == 0)
                    return;

                Print($"Remove Result: {template.Robots.Remove(template.Robots.First())}");
            };

            var indicatorsCombobox = new ComboBox();

            foreach (var indicator in AlgoRegistry.Indicators.OrderBy(i => i.Name))
            {
                indicatorsCombobox.AddItem(indicator.Name);
            }

            var addIndicatorWithDefaultParametersToSelectedTemplate = new Button {Text = "Add Indicator with default parameters to Selected Template"};

            addIndicatorWithDefaultParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (string.IsNullOrWhiteSpace(indicatorsCombobox.SelectedItem))
                {
                    Print("No indicator is selected");
                    return;
                }

                Print($"Adding indicator {indicatorsCombobox.SelectedItem}");

                template.Indicators.Add(indicatorsCombobox.SelectedItem);
            };

            var robotsCombobox = new ComboBox();

            foreach (var robot in AlgoRegistry.Robots.OrderBy(i => i.Name))
            {
                robotsCombobox.AddItem(robot.Name);
            }

            var addRobotWithDefaultParametersToSelectedTemplate = new Button {Text = "Add Robot with default parameters to Selected Template"};

            addRobotWithDefaultParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (string.IsNullOrWhiteSpace(robotsCombobox.SelectedItem))
                {
                    Print("No robot is selected");
                    return;
                }

                Print($"Adding Robot {robotsCombobox.SelectedItem}");

                template.Robots.Add(robotsCombobox.SelectedItem);
            };

            var addEmaIndicatorWithDifferentParametersToSelectedTemplate = new Button {Text = "Add EMA indicator with Different parameters to Selected Template"};

            addEmaIndicatorWithDifferentParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;

                Print($"Adding Indicator {emaType.Name} with Period 100");

                template.Indicators.Add(emaType, Bars.OpenPrices, 100);
            };

            var changeEmaIndicatorParametersForSelectedTemplate = new Button {Text = "Change EMA indicator parameters for Selected Template"};

            changeEmaIndicatorParametersForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;

                if (template.Indicators.FirstOrDefault(i => i.Type == emaType) is not {} templateIndicator)
                {
                    Print($"EMA indicator not found in template '{template.Name}'");
                    return;
                }

                Print($"Changing Indicator {emaType.Name} Period to 200");

                templateIndicator.Parameters["Periods"].Value = 200;
            };

            var setAllColorSettingsToRedForSelectedTemplate = new Button {Text = "Set All Color Setting to Red for Selected Template"};

            setAllColorSettingsToRedForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.ColorSettings.AskPriceLineColor = Color.Red;
                template.ColorSettings.BidPriceLineColor = Color.Red;
                template.ColorSettings.BackgroundColor = Color.Red;
                template.ColorSettings.BearFillColor = Color.Red;
                template.ColorSettings.BearOutlineColor = Color.Red;
                template.ColorSettings.BullFillColor = Color.Red;
                template.ColorSettings.BullOutlineColor = Color.Red;
                template.ColorSettings.BuyColor = Color.Red;
                template.ColorSettings.ForegroundColor = Color.Red;
                template.ColorSettings.GridLinesColor = Color.Red;
                template.ColorSettings.LosingDealColor = Color.Red;
                template.ColorSettings.PeriodSeparatorColor = Color.Red;
                template.ColorSettings.SellColor = Color.Red;
                template.ColorSettings.TickVolumeColor = Color.Red;
                template.ColorSettings.WinningDealColor = Color.Red;
                template.ColorSettings.AreaFillColor = Color.Red;
            };

            var enableAllDisplayOptionsForSelectedTemplate = new Button {Text = "Enable all display options for Selected Template"};

            enableAllDisplayOptionsForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.AskPriceLine = true;
                template.DisplaySettings.Bars = true;
                template.DisplaySettings.BidPriceLine = true;
                template.DisplaySettings.ChartScale = true;
                template.DisplaySettings.DealMap = true;
                template.DisplaySettings.Grid = true;
                template.DisplaySettings.IndicatorTitles = true;
                template.DisplaySettings.MarketSentiment = true;
                template.DisplaySettings.Orders = true;
                template.DisplaySettings.PeriodSeparators = true;
                template.DisplaySettings.Positions = true;
                template.DisplaySettings.PriceAlerts = true;
                template.DisplaySettings.PriceAxisOverlayButtons = true;
                template.DisplaySettings.QuickTradeButtons = true;
                template.DisplaySettings.Targets = true;
                template.DisplaySettings.TickVolume = true;
                template.DisplaySettings.AddRobotButton = true;
            };

            var disableAllDisplayOptionsForSelectedTemplate = new Button {Text = "Disable all display options for Selected Template"};

            disableAllDisplayOptionsForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.AskPriceLine = false;
                template.DisplaySettings.Bars = false;
                template.DisplaySettings.BidPriceLine = false;
                template.DisplaySettings.ChartScale = false;
                template.DisplaySettings.DealMap = false;
                template.DisplaySettings.Grid = false;
                template.DisplaySettings.IndicatorTitles = false;
                template.DisplaySettings.MarketSentiment = false;
                template.DisplaySettings.Orders = false;
                template.DisplaySettings.PeriodSeparators = false;
                template.DisplaySettings.Positions = false;
                template.DisplaySettings.PriceAlerts = false;
                template.DisplaySettings.PriceAxisOverlayButtons = false;
                template.DisplaySettings.QuickTradeButtons = false;
                template.DisplaySettings.Targets = false;
                template.DisplaySettings.TickVolume = false;
                template.DisplaySettings.AddRobotButton = false;
            };

            var changeChartTypeForSelectedTemplate = new Button {Text = "Change Chart Type for Selected Template"};

            changeChartTypeForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.ChartType = template.DisplaySettings.ChartType switch
                {
                    ChartType.Area => ChartType.Bars,
                    ChartType.Bars => ChartType.Candlesticks,
                    ChartType.Candlesticks => ChartType.Dots,
                    ChartType.Dots => ChartType.Hlc,
                    ChartType.Hlc => ChartType.Line,
                    _ => ChartType.Area
                };

                Print($"Changed template '{template.Name}' chart type to '{template.DisplaySettings.ChartType}'");
            };

            var changeZoomLevelForSelectedTemplate = new Button {Text = "Change Zoom Level for Selected Template"};

            changeZoomLevelForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.ZoomLevel = template.DisplaySettings.ZoomLevel switch
                {
                    5 => 400,
                    400 => 5,
                    _ => 5
                };

                Print($"Changed template '{template.Name}' zoom level to '{template.DisplaySettings.ZoomLevel}'");
            };

            var panel = new StackPanel {Orientation = Orientation.Vertical, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center};

            panel.AddChild(templatesComboBox);
            panel.AddChild(showTemplateInfoButton);
            panel.AddChild(showDefaultTemplateInfoButton);
            panel.AddChild(removeTemplateButton);
            panel.AddChild(applyTemplateButton);
            panel.AddChild(duplicateTemplateButton);
            panel.AddChild(createTemplateTextBox);
            panel.AddChild(createEmptyTemplateButton);
            panel.AddChild(createTemplateBasedOnChartButton);
            panel.AddChild(changeDefaultTemplateToSelectedButton);
            panel.AddChild(checkSelectedTemplateExistsButton);
            panel.AddChild(removeSelectedTemplateIndicator);
            panel.AddChild(removeSelectedTemplateBot);
            panel.AddChild(indicatorsCombobox);
            panel.AddChild(addIndicatorWithDefaultParametersToSelectedTemplate);
            panel.AddChild(robotsCombobox);
            panel.AddChild(addRobotWithDefaultParametersToSelectedTemplate);
            panel.AddChild(addEmaIndicatorWithDifferentParametersToSelectedTemplate);
            panel.AddChild(changeEmaIndicatorParametersForSelectedTemplate);
            panel.AddChild(setAllColorSettingsToRedForSelectedTemplate);
            panel.AddChild(enableAllDisplayOptionsForSelectedTemplate);
            panel.AddChild(disableAllDisplayOptionsForSelectedTemplate);
            panel.AddChild(changeChartTypeForSelectedTemplate);
            panel.AddChild(changeZoomLevelForSelectedTemplate);

            Chart.AddControl(panel);
        }
    }
}
```

Python:

```python
import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class Test():
    def on_chart_template_added(self, args):
        self.templatesComboBox.AddItem(args.ChartTemplate.Name)
        print(f"New Template added: {args.ChartTemplate.Name}")

    def on_chart_template_removed(self, args):
        self.templatesComboBox.RemoveItem(args.ChartTemplate.Name)
        print(f"Template Removed: {args.ChartTemplate.Name}")

    def on_show_template_info_button_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        print(f"Name: {template.Name} | Bots #: {template.Robots.Count} | Indicators #: {template.Indicators.Count}")

    def on_remove_selected_template_indicator_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        if template.Indicators.Count == 0:
            return

        print(f"Remove Result: {template.Indicators.Remove(next(i for i in template.Indicators))}")

    def on_remove_selected_template_bot_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        if template.Robots.Count == 0:
            return

        print(f"Remove Result: {template.Robots.Remove(next(r for r in template.Robots))}")

    def on_add_indicator_with_default_parameters_to_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        if self.indicatorsCombobox.SelectedItem is None:
            print("No indicator is selected")
            return

        print(f"Adding indicator {self.indicatorsCombobox.SelectedItem}")

        template.Indicators.Add(self.indicatorsCombobox.SelectedItem)

    def on_add_robot_with_default_parameters_to_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        if self.robotsCombobox.SelectedItem is None:
            print("No robot is selected")
            return

        print(f"Adding robot {self.robotsCombobox.SelectedItem}")

        template.Robots.Add(self.robotsCombobox.SelectedItem)

    def on_add_ema_indicator_with_different_parameters_to_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)
        emaType = IndicatorType(api.AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator))

        print(f"Adding Indicator {emaType.Name} with Period 100")

        template.Indicators.Add(emaType, api.Bars.OpenPrices, 100)

    def on_change_ema_indicator_parameters_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        emaType = IndicatorType(api.AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator))

        templateIndicator = next((x for x in template.Indicators if x.Type == emaType), None)
        if templateIndicator is None:
            print(f"EMA indicator not found in template '{template.Name}'")
            return

        print(f"Changing Indicator {emaType.Name} Period to 200")

        templateIndicator.Parameters["Periods"].Value = 200

    def on_set_all_color_settings_to_red_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        template.ColorSettings.AskPriceLineColor = Color.Red
        template.ColorSettings.BidPriceLineColor = Color.Red
        template.ColorSettings.BackgroundColor = Color.Red
        template.ColorSettings.BearFillColor = Color.Red
        template.ColorSettings.BearOutlineColor = Color.Red
        template.ColorSettings.BullFillColor = Color.Red
        template.ColorSettings.BullOutlineColor = Color.Red
        template.ColorSettings.BuyColor = Color.Red
        template.ColorSettings.ForegroundColor = Color.Red
        template.ColorSettings.GridLinesColor = Color.Red
        template.ColorSettings.LosingDealColor = Color.Red
        template.ColorSettings.PeriodSeparatorColor = Color.Red
        template.ColorSettings.SellColor = Color.Red
        template.ColorSettings.TickVolumeColor = Color.Red
        template.ColorSettings.WinningDealColor = Color.Red
        template.ColorSettings.AreaFillColor = Color.Red

    def on_enable_all_display_options_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        template.DisplaySettings.AskPriceLine = True
        template.DisplaySettings.Bars = True
        template.DisplaySettings.BidPriceLine = True
        template.DisplaySettings.ChartScale = True
        template.DisplaySettings.DealMap = True
        template.DisplaySettings.Grid = True
        template.DisplaySettings.IndicatorTitles = True
        template.DisplaySettings.MarketSentiment = True
        template.DisplaySettings.Orders = True
        template.DisplaySettings.PeriodSeparators = True
        template.DisplaySettings.Positions = True
        template.DisplaySettings.PriceAlerts = True
        template.DisplaySettings.PriceAxisOverlayButtons = True
        template.DisplaySettings.QuickTradeButtons = True
        template.DisplaySettings.Targets = True
        template.DisplaySettings.TickVolume = True
        template.DisplaySettings.AddRobotButton = True

    def on_disable_all_display_options_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        template.DisplaySettings.AskPriceLine = False
        template.DisplaySettings.Bars = False
        template.DisplaySettings.BidPriceLine = False
        template.DisplaySettings.ChartScale = False
        template.DisplaySettings.DealMap = False
        template.DisplaySettings.Grid = False
        template.DisplaySettings.IndicatorTitles = False
        template.DisplaySettings.MarketSentiment = False
        template.DisplaySettings.Orders = False
        template.DisplaySettings.PeriodSeparators = False
        template.DisplaySettings.Positions = False
        template.DisplaySettings.PriceAlerts = False
        template.DisplaySettings.PriceAxisOverlayButtons = False
        template.DisplaySettings.QuickTradeButtons = False
        template.DisplaySettings.Targets = False
        template.DisplaySettings.TickVolume = False
        template.DisplaySettings.AddRobotButton = False

    def on_change_chart_type_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        match template.DisplaySettings.ChartType:
            case ChartType.Area:
                template.DisplaySettings.ChartType = ChartType.Bars
            case ChartType.Bars:
                template.DisplaySettings.ChartType = ChartType.Candlesticks
            case ChartType.Candlesticks:
                template.DisplaySettings.ChartType = ChartType.Dots
            case ChartType.Dots:
                template.DisplaySettings.ChartType = ChartType.Hlc
            case ChartType.Hlc:
                template.DisplaySettings.ChartType = ChartType.Line
            case _:
                template.DisplaySettings.ChartType = ChartType.Area

        print(f"Changed template '{template.Name}' chart type to '{template.DisplaySettings.ChartType}'")

    def on_change_zoom_level_for_selected_template_clicked(self, args):
        if self.templatesComboBox.SelectedItem is None:
            print("No template is selected")
            return

        template = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

        match template.DisplaySettings.ZoomLevel:
            case 5:
                template.DisplaySettings.ZoomLevel = 400
            case _:
                template.DisplaySettings.ZoomLevel = 5

        print(f"Changed template '{template.Name}' zoom level to '{template.DisplaySettings.ZoomLevel}'")

    def on_change_default_template_to_selected_button_clicked(self, args):
        api.ChartTemplates.DefaultTemplate = api.ChartTemplates.Get(self.templatesComboBox.SelectedItem)

    def on_start(self):
        self.templatesComboBox = ComboBox()

        for template in api.ChartTemplates:
            self.templatesComboBox.AddItem(template.Name)

        api.ChartTemplates.Added += self.on_chart_template_added
        api.ChartTemplates.Removed += self.on_chart_template_removed

        showTemplateInfoButton = Button()
        showTemplateInfoButton.Text = "Show Template Info"
        showTemplateInfoButton.Click += self.on_show_template_info_button_clicked

        showDefaultTemplateInfoButton = Button()
        showDefaultTemplateInfoButton.Text = "Show Default Template Info"
        showDefaultTemplateInfoButton.Click += lambda args: print(f"Name: {api.ChartTemplates.DefaultTemplate.Name} | Bots #: {api.ChartTemplates.DefaultTemplate.Robots.Count} | Indicators #: {api.ChartTemplates.DefaultTemplate.Indicators.Count}")

        removeTemplateButton = Button()
        removeTemplateButton.Text = "Remove Template"
        removeTemplateButton.Click += lambda _: api.ChartTemplates.Remove(api.ChartTemplates.Get(self.templatesComboBox.SelectedItem))

        applyTemplateButton = Button()
        applyTemplateButton.Text = "Apply Template"
        applyTemplateButton.Click += lambda _: api.ChartTemplates.Get(self.templatesComboBox.SelectedItem).Apply(api.Chart)

        duplicateTemplateButton = Button()
        duplicateTemplateButton.Text = "Duplicate Template"
        duplicateTemplateButton.Click += lambda _: api.ChartTemplates.Duplicate(f"{self.templatesComboBox.SelectedItem} Duplicate", api.ChartTemplates.Get(self.templatesComboBox.SelectedItem))

        createTemplateTextBox = TextBox()
        createTemplateTextBox.Text = "Template Name"

        createEmptyTemplateButton = Button()
        createEmptyTemplateButton.Text = "Create Empty Template"
        createEmptyTemplateButton.Click += lambda _: api.ChartTemplates.Create(createTemplateTextBox.Text)

        createTemplateBasedOnChartButton = Button()
        createTemplateBasedOnChartButton.Text = "Create Template Based On Chart"
        createTemplateBasedOnChartButton.Click += lambda _: api.ChartTemplates.Create(createTemplateTextBox.Text, api.Chart)

        changeDefaultTemplateToSelectedButton = Button()
        changeDefaultTemplateToSelectedButton.Text = "Change Default Template To Selected"
        changeDefaultTemplateToSelectedButton.Click += self.on_change_default_template_to_selected_button_clicked

        checkSelectedTemplateExistsButton = Button()
        checkSelectedTemplateExistsButton.Text = "Check Selected Template Exists"
        checkSelectedTemplateExistsButton.Click += lambda _: print(f"Template {self.templatesComboBox.SelectedItem} Exists: {api.ChartTemplates.Contains(self.templatesComboBox.SelectedItem)}")

        removeSelectedTemplateIndicator = Button()
        removeSelectedTemplateIndicator.Text = "Remove Selected Template Indicator"
        removeSelectedTemplateIndicator.Click += self.on_remove_selected_template_indicator_clicked

        removeSelectedTemplateBot = Button()
        removeSelectedTemplateBot.Text = "Remove Selected Template Bot"
        removeSelectedTemplateBot.Click += self.on_remove_selected_template_bot_clicked

        self.indicatorsCombobox = ComboBox()

        for indicatorName in sorted([i.Name for i in api.AlgoRegistry.Indicators]):
            self.indicatorsCombobox.AddItem(indicatorName)

        addIndicatorWithDefaultParametersToSelectedTemplate = Button()
        addIndicatorWithDefaultParametersToSelectedTemplate.Text = "Add Indicator with default parameters to Selected Template"
        addIndicatorWithDefaultParametersToSelectedTemplate.Click += self.on_add_indicator_with_default_parameters_to_selected_template_clicked

        self.robotsCombobox = ComboBox()

        for robotName in sorted([i.Name for i in api.AlgoRegistry.Robots]):
            self.robotsCombobox.AddItem(robotName)

        addRobotWithDefaultParametersToSelectedTemplate = Button()
        addRobotWithDefaultParametersToSelectedTemplate.Text = "Add Robot with default parameters to Selected Template"
        addRobotWithDefaultParametersToSelectedTemplate.Click += self.on_add_robot_with_default_parameters_to_selected_template_clicked

        addEmaIndicatorWithDifferentParametersToSelectedTemplate = Button()
        addEmaIndicatorWithDifferentParametersToSelectedTemplate.Text = "Add EMA indicator with Different parameters to Selected Template"
        addEmaIndicatorWithDifferentParametersToSelectedTemplate.Click += self.on_add_ema_indicator_with_different_parameters_to_selected_template_clicked

        changeEmaIndicatorParametersForSelectedTemplate = Button()
        changeEmaIndicatorParametersForSelectedTemplate.Text = "Change EMA indicator parameters for Selected Template"
        changeEmaIndicatorParametersForSelectedTemplate.Click += self.on_change_ema_indicator_parameters_for_selected_template_clicked

        setAllColorSettingsToRedForSelectedTemplate = Button()
        setAllColorSettingsToRedForSelectedTemplate.Text = "Set All Color Setting to Red for Selected Template"
        setAllColorSettingsToRedForSelectedTemplate.Click += self.on_set_all_color_settings_to_red_for_selected_template_clicked

        enableAllDisplayOptionsForSelectedTemplate = Button()
        enableAllDisplayOptionsForSelectedTemplate.Text = "Enable all display options for Selected Template"
        enableAllDisplayOptionsForSelectedTemplate.Click += self.on_enable_all_display_options_for_selected_template_clicked

        disableAllDisplayOptionsForSelectedTemplate = Button()
        disableAllDisplayOptionsForSelectedTemplate.Text = "Disable all display options for Selected Template"
        disableAllDisplayOptionsForSelectedTemplate.Click += self.on_disable_all_display_options_for_selected_template_clicked

        changeChartTypeForSelectedTemplate = Button()
        changeChartTypeForSelectedTemplate.Text = "Change Chart Type for Selected Template"
        changeChartTypeForSelectedTemplate.Click += self.on_change_chart_type_for_selected_template_clicked

        changeZoomLevelForSelectedTemplate = Button()
        changeZoomLevelForSelectedTemplate.Text = "Change Zoom Level for Selected Template"
        changeZoomLevelForSelectedTemplate.Click += self.on_change_zoom_level_for_selected_template_clicked

        panel = StackPanel()
        panel.Orientation = Orientation.Vertical
        panel.HorizontalAlignment = HorizontalAlignment.Center
        panel.VerticalAlignment = VerticalAlignment.Center

        panel.AddChild(self.templatesComboBox)
        panel.AddChild(showTemplateInfoButton)
        panel.AddChild(showDefaultTemplateInfoButton)
        panel.AddChild(removeTemplateButton)
        panel.AddChild(applyTemplateButton)
        panel.AddChild(duplicateTemplateButton)
        panel.AddChild(createTemplateTextBox)
        panel.AddChild(createEmptyTemplateButton)
        panel.AddChild(createTemplateBasedOnChartButton)
        panel.AddChild(changeDefaultTemplateToSelectedButton)
        panel.AddChild(checkSelectedTemplateExistsButton)
        panel.AddChild(removeSelectedTemplateIndicator)
        panel.AddChild(removeSelectedTemplateBot)
        panel.AddChild(self.indicatorsCombobox)
        panel.AddChild(addIndicatorWithDefaultParametersToSelectedTemplate)
        panel.AddChild(self.robotsCombobox)
        panel.AddChild(addRobotWithDefaultParametersToSelectedTemplate)
        panel.AddChild(addEmaIndicatorWithDifferentParametersToSelectedTemplate)
        panel.AddChild(changeEmaIndicatorParametersForSelectedTemplate)
        panel.AddChild(setAllColorSettingsToRedForSelectedTemplate)
        panel.AddChild(enableAllDisplayOptionsForSelectedTemplate)
        panel.AddChild(disableAllDisplayOptionsForSelectedTemplate)
        panel.AddChild(changeChartTypeForSelectedTemplate)
        panel.AddChild(changeZoomLevelForSelectedTemplate)

        api.Chart.AddControl(panel)
```

config.json:

```json
{
  "AccessRights": "None",
  "AddIndicators": true
}
```

## Methods

- `bool Contains(string chartTemplateName)` — Checks if a chart template with passed name exists or not. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Contains/index.md)
- `ChartTemplate Create(string chartTemplateName, Chart chart)` — Creates a new chart template based on a chart. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Create/index.md)
- `ChartTemplate Create(string chartTemplateName)` — Creates a new chart template. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Create/index.md)
- `ChartTemplate Duplicate(string chartTemplateName, ChartTemplate chartTemplate)` — Duplicates or creates a copy of an existing chart template. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Duplicate/index.md)
- `ChartTemplate Get(string chartTemplateName)` — Returns a chart template by name if exists otherwise null. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Get/index.md)
- `bool Remove(ChartTemplate chartTemplate)` — Removes an existing chart template. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Remove/index.md)

## Properties

- `ChartTemplate DefaultTemplate {get; set;}` — Gets or sets default chart template. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/DefaultTemplate/index.md)

## Events

- `event Action<ChartTemplateAddedEventArgs> Added;` — Occurs when a new chart template is added. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Added/index.md)
- `event Action<ChartTemplateRemovedEventArgs> Removed;` — Occurs when a chart template is removed. [details](https://help.ctrader.com/ctrader-algo/references/Chart/Templates/ChartTemplates/Removed/index.md)