Programmatic management of technical indicators

Traders often rely on some combination of manual trading and automated trading helpers, especially custom indicators. However, in many cases, these helpers are completely unaware of each other and cannot react to one another's actions and outputs.

Fortunately, cTrader offers a convenient means of managing chart indicators programmatically. Using this feature, you can build dynamic assistants that read data from indicators that users add to a chart.

You can also make it so an algo adds, removes or changes indicator settings based on some conditions, allowing you to offer more value to your users and open new avenues for monetisation.

This API guide explains how you can manage chart indicators programmatically in different conditions.

Add and remove indicators programmatically

You can easily add any indicator that you have access to by calling the following method.

1

ChartIndicator ChartIndicators.Add(string name, params object[] parameterValues)

The method takes the indicator name as the first parameter and then takes all parameters of that indicator in sequence (for example, "Simple Moving Average", "High", 25).

After the method is executed, the requested indicator will immediately be added to a chart and you will be able to manage it using the value returned by the method. For example, you can remove it by calling the ChartIndicators.Remove() method.

1
2
3

var newIndicator = ChartIndicators.Add("Simple Moving Average", "High", 25);
...
ChartIndicators.Remove(newIndicator);

Here is a simple cBot that uses both methods to add a custom Bollinger Bands indicator to a chart whenever the Average True Range (ATR) value crosses a specific threshold. If the ATR value falls below the threshold, the indicator is removed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class ChartIndicatorsTest : Robot
    {

        private AverageTrueRange _aTR;
        private ChartIndicator _customBollingerBands;

        protected override void OnStart()
        {
            _aTR = Indicators.AverageTrueRange(14, MovingAverageType.Exponential);
            ChartIndicators.Add("Average True Range");
        }

        protected override void OnBar()
        {
            if (_aTR.Result[Bars.Count - 1] >= 0.0002) 
            {
                _bollingerBands = ChartIndicators.Add("Custom BB");
            } else if (_bollingerBands != null)
            {
                ChartIndicators.Remove(_bollingerBands);
            }
        }

    }
}

Modify the settings of indicators

The ChartIndicator interface provides direct access to all major indicator settings via the following properties:

• ChartIndicator.Type, which gets the type of an indicator.
• ChartIndicator.Parameters, which gets a list of all indicator parameters.
• Lines, which gets a list of all lines outputted by an indicator.

As indicators are visual aids, you can enhance them by modifying their settings depending on market conditions. The following indicator tries to do exactly that.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo
{
    [Indicator(AccessRights = AccessRights.None, IsOverlay = true)]
    public class ColourMovingAverage : Indicator
    {

        private MovingAverage _fastMA;
        private ChartIndicator _chartMA;
        private const int __lineThickness = 4;


        protected override void Initialize()
        {
            _fastMA = Indicators.MovingAverage(Bars.OpenPrices, 10, MovingAverageType.Exponential);
            _chartMA = ChartIndicators.Add("Exponential Moving Average", "Open", 10);
        }

        public override void Calculate(int index)
        {
            var line = _chartMA.Lines[0];

            if (Symbol.Bid > _fastMA.Result[index]) 
            {
                line.Color = Color.Green;
                line.Thickness = __lineThickness;
            } else 
            {
                line.Color = Color.Red;
                line.Thickness = __lineThickness;
            }
        }
    }
}

Depending on whether the current price of a symbol is above or below the exponential moving average, the indicator line changes colour and thickness. In some cases (for example, quickly reacting to changing trends), additional visual help can make all the difference.

Handle additional events

The ChartsIndicators interface also exposes several events that you can handle to programmatically manage chart indicators:

• IndicatorAdded, which is triggered every time a new indicator is added to a chart.
• IndicatorRemoved, which is triggered every time an indicator is removed from a chart.
• IndicatorModified, which is triggered every time the settings of an indicator are adjusted.

These events are valuable for developers of plugins. Via plugins, you can create new elements of the cTrader UI that change their contents depending on whether a user adds, removes or modifies indicators.

Indicator management in different modes

Here is how indicator management works across different cTrader modes and tools.

Managing chart indicators programmatically is ideal for any developer who wants to offer algos that enhance or simplify working with indicators. By leveraging this feature, you can deliver high-quality and valuable products to your users.