I will code your EAs and Indicators for no charge

For reasons of convenience to their traders - such as conforming to the internationally recognised '5pm New York market close'

However, my question was not WHY. My question is what broker/chart/historical data to use where the session opening and closing times are stamped at the same time throughout a whole year (regardless of DST is used at some moment by what ever country).

ONE IMAGE IS BETTER THAN 100 WORDS ! I WANT INDICATOR DRAW /PLOT MOVABLE HORIZONTAL LINE SO WE CAN DRAG AND DROP PRICE LABEL ANY PLACE OTHE CHART (PLEASE CHECK IMAGE)

ORIGINAL LINKS
https://www.forexfactory.com/thread/...on-window-drop

IS IT POSSIBLE?

please modify it as request.thanks

To be a little more detailed...

What Google's AI says:

Forex Trading Session Times (GMT):



So, the session opening and closing times (except for Tokyo) do NOT remain constant at GMT+0 throughout the year.

This means that even if I backtest using historical data based on a GMT+0 data feed, an EA that is supposed to place an order at the start of the London session (with a start time value of „8:00“) would be accurate in winter, but 1 hour too late in summer, because while it would still place the order at 8:00, this time would no longer coincide with the start of the London session (which would then be 7:00 AM).

The same would apply to the New York and Sydney sessions, as these also have different GMT times depending on whether it is winter or summer time.

So that's my dilemma. In other words, the EA would need to have a logic that, based on a starting time zone (e.g., GMT+0), always checks whether it's winter or daylight saving time at the time of order execution and then automatically shifts it by +/-1 hour.

Then the question is WHICH daylight saving time should it do this at? New York or Europe? Since they have different start and end times, and the dates aren't the same every year.

This is e.g. based on 2025

Europe

Daylight Saving Time began: March 30, 2025 01:00 GMT. Clocks went forward one hour.
Daylight Saving Time ends: October 26, 2025 01:00 GMT. Clocks go back one hour.

USA

Daylight Saving Time began: March 9, 2025 02:00 local time. Clocks went forward one hour.
Daylight Saving Time ends: November 2, 2025 02:00 local time. Clocks go back one hour.

You'd think it would be easy, but this is something really driving me crazy, haha...

I doubt that there exists such a broker...

An EA can auto-adjust for DST if you code it to do so.

Thank you very much! That's what I thought.

Drawing Toolbox Indicator by Jagg can do this plus more.

I'm trying to create a coloring rule, but I can't put it on my current graph. It just draws another one on top. What's wrong? Can anyone help me? Is it for MT5!

//+------------------------------------------------------------------+
//| ADX.mq5 |
//| Copyright 2025, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link "https://www.mql5.com"
#property version "1.00"
#property indicator_chart_window
#property indicator_buffers 5 // Necessário para DRAW_COLOR_CANDLES (OHLC + Cor)
#property indicator_plots 1 // Uma plotagem para colorir as velas
//--- Propriedades da plotagem "Candle_ADX"
#property indicator_label1 "Candle_ADX"
#property indicator_type1 DRAW_COLOR_CANDLES // Tipo de plotagem para colorir candles existentes
#property indicator_color1 clrBlack // Apenas uma cor: PRETO
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//--- Parâmetros de entrada (aparecerão na janela de propriedades do indicador)
input int InpADXPeriod = 14; // Período do ADX (ex: 14)
input double InpADXLevel = 27.0; // Nível do ADX para a condição (ex: 27.0)
//--- Buffers do indicador
double BufferOpen[];
double BufferHigh[];
double BufferLow[];
double BufferClose[];
double BufferColor[]; // Este é o buffer que você preencherá com o índice da cor
//--- Variáveis para o cálculo do ADX
int adx_handle;
double ADX_Values[];
//+------------------------------------------------------------------+
//| Função de inicialização do indicador |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Mapeamento dos 5 buffers.
SetIndexBuffer(0, BufferOpen, INDICATOR_DATA);
SetIndexBuffer(1, BufferHigh, INDICATOR_DATA);
SetIndexBuffer(2, BufferLow, INDICATOR_DATA);
SetIndexBuffer(3, BufferClose,INDICATOR_DATA);
SetIndexBuffer(4, BufferColor,INDICATOR_COLOR_INDEX); // O buffer de cor
//--- Definir os buffers como séries de tempo (do mais recente [0] ao mais antigo [n])
ArraySetAsSeries(BufferOpen, true);
ArraySetAsSeries(BufferHigh, true);
ArraySetAsSeries(BufferLow, true);
ArraySetAsSeries(BufferClose, true);
ArraySetAsSeries(BufferColor, true);
//--- Inicializar o buffer de cor com EMPTY_VALUE por padrão (nenhuma cor desenhada inicialmente)
PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
//--- Criar o handle para o indicador ADX nativo com o período configurável pelo usuário
adx_handle = iADX(_Symbol, _Period, InpADXPeriod); // Usa o período definido em InpADXPeriod
if(adx_handle == INVALID_HANDLE)
{
Print("OnInit: Erro ao criar handle do ADX. Verifique o período: ", InpADXPeriod);
return(INIT_FAILED);
}
ArraySetAsSeries(ADX_Values, true); // O ADX também como série
Print("OnInit: Indicador ADXColorirVelas inicializado com sucesso. ADX Periodo: ", InpADXPeriod, ", Nivel ADX: ", InpADXLevel);
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Função de cálculo do indicador |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
// Verificar se há barras suficientes para o cálculo do ADX (período InpADXPeriod)
if(rates_total < (InpADXPeriod + 1))
return(0);
// Copiar os valores do ADX
if(CopyBuffer(adx_handle, 0, 0, rates_total, ADX_Values) < rates_total)
{
Print("OnCalculate: Erro ao copiar valores do ADX ou dados insuficientes.");
return(0);
}
// Determinar o índice de início para o cálculo
int start_index = prev_calculated;
if(start_index < 0) start_index = 0;
if(start_index < (InpADXPeriod + 1)) start_index = (InpADXPeriod + 1);
// Loop pelas barras (do mais recente para o mais antigo, consistente com ArraySetAsSeries(true))
for(int i = rates_total - 1; i >= 0; i--)
{
// Limpa os buffers por padrão para barras não coloridas
BufferColor[i] = EMPTY_VALUE;
BufferOpen[i] = EMPTY_VALUE;
BufferHigh[i] = EMPTY_VALUE;
BufferLow[i] = EMPTY_VALUE;
BufferClose[i] = EMPTY_VALUE;
// Para as barras que serão coloridas, precisamos dos dados OHLC atuais
if (i + 1 < rates_total && i >= InpADXPeriod) // Garante que ADX_Values[i+1] é acessível e que ADX para 'i' é válido
{
double adx_now = ADX_Values[i];
double adx_prev = ADX_Values[i + 1];
// Condição de coloração: ADX atual > ADX anterior E ADX atual > Nível configurável (InpADXLevel)
if (adx_now > adx_prev && adx_now > InpADXLevel)
{
BufferColor[i] = 0; // Pinta a vela com a primeira (e única) cor definida: clrBlack
BufferOpen[i] = open[i];
BufferHigh[i] = high[i];
BufferLow[i] = low[i];
BufferClose[i] = close[i];
}
}
}
return(rates_total);
}
//+------------------------------------------------------------------+

- you should set the adxvalues buffer as an indicator buffer too
- in oncalc you'll need to set the ohlc parameter arrays as series to match the indicator buffers that are set as series
- when posting long bits of code you should use the </> button on the top right of a new message to then paste code inside of

I'm trying to do it like this: When the adx tilts, the candle paints black and when it "breaks" the structure (second circle) it loses the trend and returns to the normal color.


I figured it would be something: ADX (10,10) > ADX (10,10) (1) AND ADX (10,10) > 2. I'm trying to do it with chatgpt, but without success

Hello, can anyone code an arrow indicator with alerts and push notifications using these parameters?
Ext Depth 40
Ext Deviation 2
Ext backset 10

You are making your own work more difficult than it needs to be.
You need to take an existing indicator which colors the candles:

and then substitute the coloring logic with your idea.
This will also make the job for an AI easier.

Also, the ADX isn't a fixed minimum/maximum indicator.
So, you can't use hard-coded values logic.
Your logic should be comparing 3 candles - example:
ADX[i+3]<ADX[i+2]&&ADX[i+1]<ADX[i+2]

With the help of Jean Louie, I managed to change the color, but now I have another problem:


The rule then paints some candles later, I need it to paint as soon as the condition is met.

//+------------------------------------------------------------------+
//| ADX_ColoracaoVelas.mq5 |
//| Indicador de coloração de velas baseado em ADX para MetaTrader 5 |
//| Autor: Baseado em solicitações do usuário |
//| Data: 2025.06.18 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Baseado em solicitações do usuário"
#property link "https://www.mql5.com"
#property version "1.00"
#property indicator_chart_window // O indicador será exibido na janela principal do gráfico
// Definir o número de buffers necessários:
// 4 para dados OHLC da vela customizada (Abertura, Máxima, Mínima, Fechamento)
// 1 para o índice de cor (BufferCor)
#property indicator_buffers 5
#property indicator_plots 1 // Uma única plotagem para a coloração personalizada
//--- Propriedades da plotagem "Vela_ADX"
#property indicator_label1 "Vela_ADX" // Rótulo para a plotagem na Janela de Dados
#property indicator_type1 DRAW_COLOR_CANDLES // Tipo de plotagem para colorir as velas existentes
#property indicator_color1 clrBlack // A cor personalizada que o indicador irá pintar: PRETO
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//--- Parâmetros de entrada (aparecerão na janela de propriedades do indicador no MT5)
input int InpADXPeriodo = 8; // Período do ADX (fixo em 8, conforme a regra do usuário)
input double InpADXNivel = 2.0; // Nível do ADX para a condição (valor configurável, use para calibrar a seletividade)
//--- Buffers de dados para a plotagem personalizada das velas
double BufferAbertura[];
double BufferMaxima[];
double BufferMinima[];
double BufferFechamento[];
double BufferCor[]; // Buffer para o índice de cor (0 para clrBlack, EMPTY_VALUE para não pintar)
//--- Buffers e handle para o indicador técnico iADX() do MetaTrader
int handle_adx;
double ValoresADX_aux[];
double ValoresMaisDI_aux[];
double ValoresMenosDI_aux[];

//+------------------------------------------------------------------+
//| Função de inicialização do indicador (executada uma vez ao anexar) |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Mapeamento dos buffers do indicador para o MetaTrader
SetIndexBuffer(0, BufferAbertura, INDICATOR_DATA);
SetIndexBuffer(1, BufferMaxima, INDICATOR_DATA);
SetIndexBuffer(2, BufferMinima, INDICATOR_DATA);
SetIndexBuffer(3, BufferFechamento, INDICATOR_DATA);
SetIndexBuffer(4, BufferCor, INDICATOR_COLOR_INDEX); // Este buffer armazena o índice da cor
//--- Definir todos os buffers como séries de tempo (indexação do mais recente para o mais antigo)
ArraySetAsSeries(BufferAbertura, true);
ArraySetAsSeries(BufferMaxima, true);
ArraySetAsSeries(BufferMinima, true);
ArraySetAsSeries(BufferFechamento, true);
ArraySetAsSeries(BufferCor, true);
//--- Inicializar os buffers de plotagem com EMPTY_VALUE.
// Isso garante que, por padrão, o indicador não desenhe nada,
// permitindo que as velas mantenham suas cores padrão (verde/vermelho).
PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
//--- Cria o handle (identificador) para o indicador iADX() nativo do MetaTrader.
// O iADX() fornece os valores do ADX (buffer 0), +DI (buffer 1), e -DI (buffer 2).
handle_adx = iADX(_Symbol, _Period, InpADXPeriodo);
//--- Verifica se o handle do ADX foi criado com sucesso
if(handle_adx == INVALID_HANDLE)
{
Print("OnInit: Erro ao criar handle do ADX. Verifique o período: ", InpADXPeriodo);
return(INIT_FAILED); // Falha na inicialização do indicador
}
//--- Definir os arrays auxiliares para o ADX, +DI e -DI como séries de tempo
ArraySetAsSeries(ValoresADX_aux, true);
ArraySetAsSeries(ValoresMaisDI_aux, true);
ArraySetAsSeries(ValoresMenosDI_aux, true);
Print("OnInit: Indicador ADX_ColoracaoVelas inicializado com sucesso. ADX Periodo: ", InpADXPeriodo, ", Nivel ADX: ", InpADXNivel);
return(INIT_SUCCEEDED); // Inicialização bem-sucedida
}
//+------------------------------------------------------------------+
//| Função de cálculo do indicador (executada a cada tick ou nova barra) |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, // Número total de barras no gráfico
const int prev_calculated, // Número de barras já calculadas na execução anterior
const datetime &time[], // Array de tempos das barras
const double &open[], // Array de preços de abertura
const double &high[], // Array de preços máximos
const double &low_arr[], // Array de preços mínimos (renomeado para evitar conflito)
const double &close[], // Array de preços de fechamento
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
// --- Configura os arrays OHLC de entrada como séries de tempo ---
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low_arr, true);
ArraySetAsSeries(close, true);
//--- Verifica se há barras suficientes para realizar os cálculos do ADX e comparações
// O ADX precisa de no mínimo InpADXPeriodo barras. Para comparar ADX_atual com ADX_anterior, precisamos de 2 barras de ADX válidas.
if(rates_total < (InpADXPeriodo + 2))
{
// Se não há dados suficientes, limpa o que estiver nos buffers para não exibir nada.
for(int i = 0; i < rates_total; i++)
{
BufferAbertura[i] = EMPTY_VALUE;
BufferMaxima[i] = EMPTY_VALUE;
BufferMinima[i] = EMPTY_VALUE;
BufferFechamento[i] = EMPTY_VALUE;
BufferCor[i] = EMPTY_VALUE;
}
return(0); // Não há dados suficientes para calcular, retorna 0 barras processadas
}
//--- Define o ponto de início do loop de cálculo
// Queremos sempre recalcular a barra atual (índice 0) e a barra anterior (índice 1),
// pois a barra 1 pode ter sido a barra 0 na última atualização e precisa ter sua cor finalizada.
// As barras históricas (além da barra 1) precisam ser calculadas apenas uma vez.
int start_calc_idx;
if(prev_calculated == 0)
{
// Se é a primeira vez que o indicador está sendo calculado no gráfico,
// calculamos todas as barras até o ponto onde o ADX começa a ser válido.
// A condição 'i >= InpADXPeriodo' dentro do loop cuidará disso.
start_calc_idx = 0;
}
else
{
// Em atualizações subsequentes (a cada tick ou nova barra),
// precisamos recalcular a barra atual (0) e a barra que acabou de fechar (1).
// O loop deve começar do rates_total - 1 (barra 0) e ir até rates_total - 2 (barra 1).
// Usamos 'MathMax' para garantir que start_calc_idx não seja negativo ou maior que rates_total-1
start_calc_idx = MathMax(0, rates_total - 2);
}

//--- Copia os valores dos buffers do indicador iADX() para os nossos arrays auxiliares
// Fazemos uma cópia completa para garantir que os dados de todas as barras, incluindo a 0, estejam atualizados.
if(CopyBuffer(handle_adx, 0, 0, rates_total, ValoresADX_aux) < rates_total ||
CopyBuffer(handle_adx, 1, 0, rates_total, ValoresMaisDI_aux) < rates_total ||
CopyBuffer(handle_adx, 2, 0, rates_total, ValoresMenosDI_aux) < rates_total)
{
Print("OnCalculate: Erro ao copiar valores do ADX/DI. Dados insuficientes ou erro de handle.");
return(0);
}
// --- Loop principal de cálculo das velas coloridas ---
// O loop percorre as barras do mais recente (rates_total - 1) para o mais antigo (start_calc_idx).
// Isso garante que a barra 0 (atual) seja sempre a primeira a ser processada e atualizada.
for(int i = rates_total - 1; i >= start_calc_idx; i--)
{
// Primeiro, limpa os buffers de plotagem para a barra atual.
// Isso faz com que a vela retorne à sua cor padrão (verde/vermelho) se a condição não for atendida,
// ou se ela não deve ser pintada.
BufferAbertura[i] = EMPTY_VALUE;
BufferMaxima[i] = EMPTY_VALUE;
BufferMinima[i] = EMPTY_VALUE;
BufferFechamento[i] = EMPTY_VALUE;
BufferCor[i] = EMPTY_VALUE;
//--- Verifica se há dados ADX/DI válidos para esta barra (i) e a barra anterior (i+1)
// O ADX é um indicador suavizado e precisa de dados anteriores.
// A condição `i >= InpADXPeriodo` garante que o ADX para a barra `i` é válido.
// A condição `(i + 1) < rates_total` garante que `ADX_anterior` exista.
if (i >= InpADXPeriodo && (i + 1) < rates_total)
{
double adx_atual = ValoresADX_aux[i];
double adx_anterior = ValoresADX_aux[i + 1]; // ADX da vela anterior (já fechada se i=0)
double mais_di_atual = ValoresMaisDI_aux[i];
double menos_di_atual = ValoresMenosDI_aux[i];
//--- Condição principal para colorir a vela de PRETO:
// 1. O ADX atual deve ser maior que o ADX anterior (tendência está ganhando força).
// 2. E o ADX atual deve ser maior que o nível mínimo configurado (força é significativa).
// 3. E (o +DI deve ser maior que o -DI OU o -DI deve ser maior que o +DI)
// Esta parte garante que há uma direção clara de tendência (não lateral).
if (adx_atual > adx_anterior && // ADX está subindo (força da tendência aumentando)
adx_atual > InpADXNivel && // A força da tendência está acima de um nível mínimo
(mais_di_atual > menos_di_atual || menos_di_atual > mais_di_atual)) // Há uma direção de tendência clara (+DI > -DI ou -DI > +DI)
{
BufferCor[i] = 0; // Define o índice de cor para 0 (que corresponde a clrBlack)

// Atribui os dados OHLC da barra 'i' para que a vela personalizada seja desenhada.
// Para a barra atual (i=0), 'open[0]', 'high[0]', 'low_arr[0]', 'close[0]' já refletem os valores em tempo real.
BufferAbertura[i] = open[i];
BufferMaxima[i] = high[i];
BufferMinima[i] = low_arr[i];
BufferFechamento[i] = close[i];
}
}
}

// Retorna o número de barras que foram processadas.
// Isso ajuda o MT5 a otimizar futuros cálculos.
// Retornamos rates_total para que o MT5 entenda que todas as barras válidas foram consideradas.
return rates_total;
}
//+------------------------------------------------------------------+

Your logic should be comparing 3 candles - example:

Please don't paste codes directly in the post's text!!!

This may be what you're after.

ADX_CandleColor
- colored candles based on adx values below-

1. - main line rising, color is +- line on top
2. - main line above level, color is +- line on top
3. - main line above level and rising, color is +- line on top
4. - +- line on top

- you can change the neutral color to none to not show it and see the normal chart candles

It turned out really well, but in the case of the candle with the arrow, he didn't paint it black. The ADX I'm using is Wilder.
Basically, he would have to paint it every time the ADX tilted.

That pic doesn't look like any color type from the indicator I posted, as far as I can tell there are no issues with the posted indicator.
If the pic is my indicator then double check the atr period and level are the same as the subwindow, and mention the coloring type if there is an issue.

I tried to do this with the AI, but it only paints the candles after 7 to 8 candles. I couldn't get it to paint at the same time that the ADX is pointing to the possible trend. Is there a way to let it update on the same bar?

arrow indicators are repainting so there would be no point of having alerts
i have a version which is with fibo projection with impulse (longer than previous) wave

Hello,
I would like to put in my chart two of this indicator...it is possible?
thank's in advance