Modèles de graphiques

La collection ChartTemplates et les objets ChartTemplate vous permettent d'enregistrer, de gérer et d'appliquer par programmation des modèles de graphiques, sans avoir à gérer des configurations manuelles. Cette fonctionnalité est utile pour :

Les traders qui souhaitent que les algorithmes configurent et gèrent des dispositions de graphiques cohérentes, un changement de modèle fluide, la capture et le stockage de configurations, la surveillance et plus encore.
Les développeurs qui ont besoin d'environnements de graphiques reproductibles pour l'analyse avancée, la surveillance, le débogage ou le déploiement d'indicateurs d'aide et de cBots sur de nombreux graphiques.

Concepts de base

Un seul ChartTemplate expose :

template.Apply(Chart) pour appliquer un modèle à un graphique cible.
template.Indicators pour ajouter ou supprimer des indicateurs, accéder à leurs paramètres.
template.Robots pour ajouter ou supprimer des cBots.
template.ColorSettings pour travailler avec les couleurs du graphique ou du thème
template.DisplaySettings pour travailler avec le type de graphique, le zoom et divers boutons bascule, y compris les positions, les ordres, la grille, le sentiment et plus encore.

L'objet ChartTemplates, une collection intégrée, fournit :

foreach (var t in ChartTemplates) ... pour l'énumération.
ChartTemplates.Get(name), ChartTemplates.Contains(name) pour les requêtes.
ChartTemplates.Create(name) pour créer des modèles vides.
ChartTemplates.Create(name, Chart) pour capturer la configuration actuelle du graphique.
ChartTemplates.Duplicate(newName, sourceTemplate) pour dupliquer des modèles.
ChartTemplates.Remove(template) pour supprimer des modèles.
ChartTemplates.DefaultTemplate pour appliquer le modèle par défaut (obtenir ou définir).

Il expose également des événements :

ChartTemplates.Added += ...
ChartTemplates.Removed += ...

Le tableau ci-dessous fournit un résumé des opérations standard.

Opération	Exemples
Cycle de vie du modèle	Créer un modèle vide Créer un modèle à partir du graphique actuel Dupliquer un modèle Supprimer un modèle
Découverte de modèles	Lister les modèles et afficher les données Vérifier si un modèle existe Réagir à l'ajout ou à la suppression d'un modèle
Application de modèles	Appliquer un modèle à un graphique Modifier le modèle par défaut
Composition de modèles	Ajouter ou supprimer un indicateur Modifier les paramètres d'un indicateur Ajouter ou supprimer un cBot
Paramètres de disposition et de visualisation	Définir les couleurs du graphique Activer ou désactiver les options d'affichage du graphique Modifier le type de graphique Ajuster le niveau de zoom

Considérez un cBot Chart Templates Manager qui, lorsqu'il est ajouté et démarré sur un graphique, affiche un menu pour effectuer diverses tâches avec les modèles de graphiques.

Vue par défautSélection de modèlesChoix d'indicateursAjout de cBots

Code

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

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class ChartTemplatesManager : Robot
    {
        protected override void OnStart()
        {
            var templatesComboBox = new ComboBox();

            templatesComboBox.AddItem("Click to view available templates");
            templatesComboBox.SelectedItem = "Click to view available templates";

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

            ChartTemplates.Added += args =>
            {
                templatesComboBox.AddItem(args.ChartTemplate.Name);
                Print($"A new template was added: {args.ChartTemplate.Name}");
            };

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

            var showTemplateInfoButton = new Button { Text = "Show the template information" };

            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 the default template information" };

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

            var removeTemplateButton = new Button { Text = "Remove the selected template" };

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

            var applyTemplateButton = new Button { Text = "Apply the selected template" };

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

            var duplicateTemplateButton = new Button { Text = "Duplicate the selected template" };

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

            var createTemplateTextBox = new TextBox { Text = "Click to type in a template name" };

            var createEmptyTemplateButton = new Button { Text = "Create an empty template" };

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

            var createTemplateBasedOnChartButton = new Button { Text = "Create a template from the current chart" };

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

            var changeDefaultTemplateToSelectedButton = new Button { Text = "Set the selected template as the default" };

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

            var checkSelectedTemplateExistsButton = new Button { Text = "Check whether the selected template exists" };

            checkSelectedTemplateExistsButton.Click += _ => Print($"The template '{templatesComboBox.SelectedItem}' exists: {ChartTemplates.Contains(templatesComboBox.SelectedItem)}");

            var removeSelectedTemplateIndicator = new Button { Text = "Remove an indicator from the selected template" };

            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($"Removal result: {template.Indicators.Remove(template.Indicators.First())}");
            };

            var removeSelectedTemplateBot = new Button { Text = "Remove a cBot from the selected template" };

            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($"Removal result: {template.Robots.Remove(template.Robots.First())}");
            };


            var indicatorsCombobox = new ComboBox();

            indicatorsCombobox.AddItem("Click to select an indicator");
            indicatorsCombobox.SelectedItem = "Click to select an indicator";

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

            var addIndicatorWithDefaultParametersToSelectedTemplate = new Button { Text = "Add the selected indicator to the selected template using default parameters" };

            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($"Added the indicator {indicatorsCombobox.SelectedItem}.");

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

            var robotsCombobox = new ComboBox();

            robotsCombobox.AddItem("Click to select a cBot");
            robotsCombobox.SelectedItem = "Click to select a cBot";

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

            var addRobotWithDefaultParametersToSelectedTemplate = new Button { Text = "Add the selected cBot to the selected template using default parameters" };

            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 cBot is selected.");
                    return;
                }

                Print($"Added the cBot {robotsCombobox.SelectedItem}.");

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

            var addEmaIndicatorWithDifferentParametersToSelectedTemplate = new Button { Text = "Add an EMA indicator to the selected template using custom parameters" };

            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($"Added the indicator {emaType.Name} with a period of 100.");

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

            var changeEmaIndicatorParametersForSelectedTemplate = new Button { Text = "Change the EMA indicator parameters in the 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($"The EMA indicator was not found in the template '{template.Name}'.");
                    return;
                }

                Print($"Changing the indicator {emaType.Name} period to 200.");

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

            var setAllColorSettingsToRedForSelectedTemplate = new Button { Text = "Set all colour settings to red for the 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 the 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 the 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 the chart type for the 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 the template '{template.Name}' chart type to '{template.DisplaySettings.ChartType}'.");
            };

            var changeZoomeLevelForSelectedTemplate = new Button { Text = "Change the zoom level for the selected template" };

            changeZoomeLevelForSelectedTemplate.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 the 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(changeZoomeLevelForSelectedTemplate);

            Chart.AddControl(panel);
        }
    }
}

Applications pratiques

Capturer la configuration actuelle

Développez des algorithmes qui capturent par programmation les paramètres d'un graphique, y compris les indicateurs, les paramètres, les couleurs et autres, et les stockent sous forme de modèle. Cela vous permet de préserver automatiquement une configuration de travail pendant n'importe quelle phase du trading algorithmique et de l'appliquer à n'importe quel autre graphique.

Ce code C# démontre un cBot qui capture et stocke le modèle d'un graphique :

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

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class CaptureChartAsTemplate : Robot
    {
        [Parameter("Template Name", DefaultValue = "My Golden Layout")]
        public string TemplateName { get; set; }

        protected override void OnStart()
        {
            // If you want "overwrite", remove first (safe pattern).
            if (ChartTemplates.Contains(TemplateName))
            {
                var existing = ChartTemplates.Get(TemplateName);
                ChartTemplates.Remove(existing);
                Print($"Removed existing template '{TemplateName}' to recapture.");
            }

            // Capture everything from the CURRENT chart (indicators/robots/colors/display settings).
            var created = ChartTemplates.Create(TemplateName, Chart);

            Print($"Captured template '{created.Name}' from current chart. " +
                  $"Indicators={created.Indicators.Count}, Robots={created.Robots.Count}");
        }
    }
}

Créer des espaces de travail distincts

Structurez votre flux de travail discrétionnaire en trois dispositions de graphiques dédiées et basculez entre elles instantanément. Un flux de travail discrétionnaire courant est :

Analyser – graphique minimal, chargement rapide, chandeliers japonais propres, sans encombrement.
Confirmer – indicateurs et superpositions de contexte, tels que les filtres de tendance/volatilité.
Exécuter – afficher les ordres/positions/objectifs et les boutons Quick Trade, masquer tout ce qui distrait.

private void ApplyWorkspace(string name)
{
    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Standardiser le trading de tendance

Vous vous appuyez généralement sur trois éléments de base lors du trading de tendances : un filtre de tendance tel qu'une EMA, une mesure de momentum ou de surachat-survente telle que le RSI et un graphique en chandeliers japonais propre avec des couleurs stables et des superpositions lisibles. Vous pouvez enregistrer cette configuration en tant que modèle unique et l'appliquer à n'importe quel symbole ou intervalle de temps que vous ouvrez.

Une configuration standardisée vous aide à éviter les incohérences de paramètres, à réduire les erreurs de configuration et à garantir que chaque graphique suit le même cadre de décision.

var t = ChartTemplates.Get("Trend Setup");

t.Indicators.Add("Relative Strength Index");

var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;
t.Indicators.Add(emaType, Bars.OpenPrices, 200);

t.DisplaySettings.ChartType = ChartType.Candlesticks;
t.DisplaySettings.ZoomLevel = 200;

t.Apply(Chart);

Créer des dispositions de retour à la moyenne

Lors du trading de retour à la moyenne, vous vous appuyez souvent sur davantage de contexte d'indicateurs, mais vous souhaitez toujours un graphique propre et contrôlé. Utilisez des modèles pour décider exactement ce qui reste visible pendant l'analyse.

Désactivez les boutons Quick Trade pour éviter les entrées accidentelles. Masquez le panneau de sentiment s'il vous distrait. Gardez la grille et les niveaux clés visibles pour un positionnement précis. Choisissez le type de graphique qui correspond à votre approche, que ce soit des chandeliers japonais pour la structure ou un graphique linéaire pour la clarté.

var mr = ChartTemplates.Get("Mean Reversion");

mr.DisplaySettings.QuickTradeButtons = false;
mr.DisplaySettings.MarketSentiment = false;
mr.DisplaySettings.Grid = true;
mr.DisplaySettings.Orders = true;
mr.DisplaySettings.Positions = true;

mr.Apply(Chart);

Créer des modèles de surveillance

Lorsque vous êtes dans un trade, vos priorités changent. Vous avez besoin d'une visibilité claire des positions ouvertes, des ordres en cours et des niveaux cibles, ainsi que d'une vue de graphique stable et cohérente. Maintenez votre niveau de zoom fixe, assurez-vous que les lignes de prix sont clairement affichées et supprimez les indicateurs qui ne soutiennent pas directement les décisions de gestion.

var monitor = ChartTemplates.Get("Monitor");

monitor.DisplaySettings.Positions = true;
monitor.DisplaySettings.Orders = true;
monitor.DisplaySettings.Targets = true;
monitor.DisplaySettings.PriceAlerts = true;

monitor.DisplaySettings.IndicatorTitles = false;   // reduce noise
monitor.DisplaySettings.ZoomLevel = 150;

monitor.Apply(Chart);

Appliquer des normes visuelles

Si vous travaillez au sein d'une équipe ou suivez un style de poste de travail défini, utilisez des modèles pour standardiser des éléments tels que la couleur d'arrière-plan, les couleurs des chandeliers haussiers et baissiers, la visibilité de la grille et le style de ligne. Appliquez le même modèle sur tous les graphiques pour garantir une structure visuelle uniforme, réduire la confusion et améliorer la communication.

Cette configuration devient particulièrement importante lorsque vous partagez des captures d'écran, effectuez des revues de stratégie ou déléguez des décisions.

var style = ChartTemplates.Get("House Style");

style.ColorSettings.BackgroundColor = Color.Black;
style.ColorSettings.ForegroundColor = Color.White;
style.ColorSettings.GridLinesColor = Color.Gray;
style.ColorSettings.BullFillColor = Color.Green;
style.ColorSettings.BearFillColor = Color.Red;

style.Apply(Chart);

Ajouter des modèles de volatilité

Lorsque la volatilité change, vos besoins d'exécution et d'analyse changent. Créez des modèles pour définir deux espaces de travail distincts et basculez entre eux à mesure que les conditions évoluent :

Dans le modèle de faible volatilité, utilisez un zoom plus serré, réduisez les superpositions et maintenez une vue propre adaptée au trading de range.
Dans le modèle de forte volatilité, utilisez un zoom plus large, des lignes de prix plus claires, activez la grille et affichez les positions et les ordres pour un contrôle d'exécution plus strict.

private void ApplyRegimeTemplate(bool highVol)
{
    var name = highVol ? "HighVol" : "LowVol";
    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Créer des contextes en un clic

Vous utilisez souvent différents paramètres d'indicateurs, niveaux de zoom et préférences visuelles selon que vous faites du scalping ou du swing trading. Au lieu d'ajuster manuellement les paramètres chaque fois que vous changez d'intervalle de temps, créez des modèles dédiés pour chaque vue.

Par exemple, définissez M1-Scalp pour une exécution rapide et un zoom plus serré, M15-Intraday pour un trading de session structuré et H1-Swing pour un contexte plus large et des superpositions plus fluides.

private void ApplyTimeframeWorkspace(TimeFrame tf)
{
    var name =
        tf == TimeFrame.Minute ? "M1-Scalp" :
        tf == TimeFrame.Minute15 ? "M15-Intraday" :
        "H1-Swing";

    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Créer des playbooks de stratégie

Si vous tradez plusieurs familles de stratégies, envisagez de définir un modèle dédié pour chaque playbook. Par exemple, vous pouvez :

Utiliser un modèle de playbook de breakout avec la grille activée, les ordres et les positions visibles, un zoom plus large et des lignes de prix propres pour la clarté d'exécution.
Utiliser un modèle de playbook de pullback avec EMA et RSI appliqués, un niveau de zoom normal et les titres d'indicateurs visibles.
Utilisez un modèle de playbook de retournement avec des indicateurs de contexte supplémentaires et un type de bougie qui met en évidence les mèches et la structure.

Avec chaque playbook encodé comme modèle, vous pouvez changer d'environnement en fonction du type de signal et maintenir votre exécution alignée avec la stratégie que vous appliquez.

private void ApplyPlaybook(string playbook)
{
    var name = playbook switch
    {
        "Breakout" => "Breakout Playbook",
        "Pullback" => "Pullback Playbook",
        "Reversal" => "Reversal Playbook",
        _ => "Scan"
    };

    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}