//+------------------------------------------------------------------+
//|                                                     IndBruno.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| DIRETIVAS && PRÉ-PROCESSADORES                                   |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2022, MetaQuotes Software Corp."
#property link        "brunoronzani@gmail.com - +55 (48)99933-2600"
#property version     "10.9"
#property description "TOPOS e FUNDOS, SUPORTES e RESISTÊNCIAS, PULLBACK e DRAWBACK, PULLBACK2 (SECUNDÁRIO), DRAWBACK2 (SECUNDÁRIO), LTA e LTB"
//---
#property indicator_chart_window                //--- Exibe o indicador na janela do gráfico e, não em janela separada
//---
//+------------------------------------------------------------------+
//| CARACTERÍSTICAS GERAIS DO INDICADOR                              |
//+------------------------------------------------------------------+
//---
#property indicator_buffers 30                  //--- vetor de dados/buffers
#property indicator_plots   30                  //--- plotagens gráficas
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - TOPOS
#property indicator_label1       "Topos"
//--- plotar Invisível 
#property indicator_type1   DRAW_NONE 
//#property indicator_style1  STYLE_SOLID 
//#property indicator_color1  clrRed 
//#property indicator_width1  1 
//--- CARACTERÍSTICAS ESPECÍFICAS - FUNDOS
#property indicator_label2       "Fundos"
#property indicator_type2   DRAW_NONE 
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - SUPORTES
#property indicator_label3       "Suportes"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - RESISTÊNCIAS
#property indicator_label4       "Resistências"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - PULLBACK
#property indicator_label5       "Pullback"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - DRAWBACK
#property indicator_label6       "Drawback"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - PULLBACK SECUNDÁRIO
#property indicator_label7       "Pulback Secundário"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - DRAWBACK SECUNDÁRIO
#property indicator_label8       "Drawback Secundário" 
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - LTA - LINHA DE TENDÊNCIA DE ALTA
#property indicator_label9       "LTA - Linha de Tendência de Alta"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - LTB - LINHA DE TENDÊNCIA DE BAIXA
#property indicator_label10      "LTB - Linha de Tendência de Baixa"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - MÁXIMA DO PRIMEIRO CANDLE DO DIA
#property indicator_label11      "Máxima Primeiro Candle"
//---
//--- CARACTERÍSTICAS ESPECÍFICAS - MÍNIMA DO PRIMEIRO CANDLE DO DIA
#property indicator_label12      "Mínima Primeiro Candle"
//---
struct base_dados {
   //--- PRIMEIRA BARRA DO DIA
   double   highFirstBar;           //--- MáXIMA da primeira barra do dia
   double   lowFirstBar;            //--- MíNIMA da primeira barra do dia
   double   distFirstBar;           //--- DISTâNCIA entre a máxima e mínima da primeira barra do dia
   double   topo;                   //--- Dados do ÚLTIMO TOPO registrado
   double   fundo;                  //--- Dados do ÚLTIMO FUNDO registrado
   int      firstBar;               //--- Dados da última "primeira barra do dia" registrada
   bool     memFirstBar;            //--- Booleana "primeira barra do dia" = true
   //--- TOPOS e FUNDOS   
   datetime gatilhoFundoPrecoTFdt;  //--- Horário do gatilho de FUNDO                                       --- FUNDOS   
   double   gatilhoFundoPrecoTF;    //--- Preço de gatilho para registro do "último fundo"
   double   gatilhoFundoMaxTF;      //--- Preço de gatilho para registro da máx do "último fundo"
   bool     gatilhoFundoTF;         //--- Preço de gatilho que confirma e registra o "último fundo"
   datetime gatilhoTopoPrecoTFdt;   //--- Horário do gatilho de TOPO                                        --- TOPOS  
   double   gatilhoTopoPrecoTF;     //--- Preço de gatilho para registro do "último topo"
   double   gatilhoTopoMinTF;       //--- Preço de gatilho para registro da min do "último topo"
   bool     gatilhoTopoTF;          //--- Preço de gatilho que confirma e registra o "último topo"
   //--- SUPORTES e RESISTÊNCIAS   
   datetime gatilhoFundoPrecoSRdt;  //--- Horário do gatilho de SUPORTE                                     --- SUPORTES 
   double   gatilhoFundoPrecoSR;    //--- Preço de gatilho para registro do "último SUPORTE"
   double   gatilhoFundoMaxSR;      //--- Preço de gatilho para registro da máx do "último SUPORTE"
   bool     gatilhoFundoSR;         //--- Preço de gatilho que confirma e registra o "último SUPORTE"
   datetime gatilhoTopoPrecoSRdt;   //--- Horário do gatilho de RESISTÊNCIA                                 --- RESISTÊNCIAS 
   double   gatilhoTopoPrecoSR;     //--- Preço de gatilho para registro da "última RESISTÊNCIA"
   double   gatilhoTopoMinSR;       //--- Preço de gatilho para registro da min da "última RESISTÊNCIA"
   bool     gatilhoTopoSR;          //--- Preço de gatilho que confirma e registra a "última RESISTÊNCIA"   
   //--- PULLBACK e DRAWBACK  
   datetime gatilhoFundoPrecoPDdt;  //--- Horário do gatilho do preço de PULLBACK                           --- PULLBACK 
   double   gatilhoFundoPrecoPD;    //--- Preço de gatilho para registro do "último PULLBACK"
   double   gatilhoFundoMaxPD;      //--- Preço de gatilho para registro da máx do "último PULLBACK"
   bool     gatilhoFundoPD;         //--- Preço de gatilho que confirma e registra o "último PULLBACK"
   datetime gatilhoTopoPrecoPDdt;   //--- Horário do gatilho do preço de DRAWBACK                           --- DRAWBACK
   double   gatilhoTopoPrecoPD;     //--- Preço de gatilho para registro do "último DRAWBACK"
   double   gatilhoTopoMinPD;       //--- Preço de gatilho para registro da min do "último DRAWBACK"
   bool     gatilhoTopoPD;          //--- Preço de gatilho que confirma e registra o "último DRAWBACK"     
   double   drawback[];             //--- Vetor de DRAWBACK
   double   pullback[];             //--- Vetor PULLBACK
   //--- PULLBACK2 (SECUNDÁRIO) e DRAWBACK2 (SECUNDÁRIO)
   datetime gatilhoFundoPrecoPD2dt; //--- Horário do gatilho do preço de PULLBACK2 (SECUNDÁRIO)             --- PULLBACK2 (SECUNDÁRIO) 
   double   gatilhoFundoPrecoPD2;   //--- Preço de gatilho para registro do "último PULLBACK2"
   double   gatilhoFundoMaxPD2;     //--- Preço de gatilho para registro da máx do "último PULLBACK2"
   bool     gatilhoFundoPD2;        //--- Preço de gatilho que confirma e registra o "último PULLBACK2"
   datetime gatilhoTopoPrecoPD2dt;  //--- Horário do gatilho do preço de DRAWBACK2 (SECUNDÁRIO)             --- DRAWBACK2 (SECUNDÁRIO)
   double   gatilhoTopoPrecoPD2;    //--- Preço de gatilho para registro do "último DRAWBACK2"
   double   gatilhoTopoMinPD2;      //--- Preço de gatilho para registro da min do "último DRAWBACK2"
   bool     gatilhoTopoPD2;         //--- Preço de gatilho que confirma e registra o "último DRAWBACK2"     
   double   drawback2[];            //--- Vetor de DRAWBACK
   double   pullback2[];            //--- Vetor PULLBACK
   //--- LTA - LINHA DE TENDÊNCIA DE ALTA e LTB - LINHA DE TENDÊNCIA DE BAIXA

   //double   arrayMaxD1[];
   //double   arrayMinD1[];
};
base_dados setup;                   //Variável do tipo setup
//+------------------------------------------------------------------+
//| INPUTS                                                           |
//+------------------------------------------------------------------+ 
input bool               InpUseIndVisible                = true;                //--- Indicadores Visíveis (Sim=true/Não=false) - ainda não está sendo usado no indBruno
//--- Parâmetro TIMEFRAME para a Coleta dos DADOS
input ENUM_TIMEFRAMES    InpTimeFrameTopoFundo           = 0;                   //--- Time frame TOPOS e FUNDOS - ainda não está sendo usado no indBruno
input ENUM_TIMEFRAMES    InpTimeFrameLTAeLTB             = 0;                   //--- Time frame LTA e LTB - ainda não está sendo usado no indBruno
//--- parâmetro GERAL de TOPOS e FUNDOS
input bool               InpUseFilterTopoFundo           = true;                //--- Usar Filtro GERAL TOPOS E FUNDOS (Sim=true/Não=false)
input double             InpFilterTopoFundo              = 500.0;               //--- Parâmetro GERAL TOPOS E FUNDOS
input double             InputMargemGatilhoTF            = 20.0;                 //--- Margem Gatilho TOPOS E FUNDOS
//--- Parâmetro Específico de TOPOS e FUNDOS em relação ao 1º Candle - FirstBar
input bool               InpUseFilterTopoFundo1Candle    = true;                //--- Usar Filtro Específico TOPOS E FUNDOS (Sim=true/Não=false) - FirstBar
input double             InputMaiorQ1CandledoDia         = 20.0;                //--- Parâmetro ESPECÍFICO 1º TOPO E FUNDO - MAIOR QUE - FirstBar
input double             InputMenorQ1CandledoDia         = 300.0;               //--- Parâmetro ESPECÍFICO 1º TOPO E FUNDO - MENOR QUE - FirstBar
//--- Parâmetro Específico de Distância para PullBack e Drawback
input bool               InpUseFilterDistanciaPullBack   = true;                //--- Usar Distância PullBack (Sim=true/Não=false)
input string             InpFilterDistanciaPullBack      = "10|20|30|40|50";    //--- Distância PULLBACK e DRAWBACK em percentuais
//--- Parâmetro MARGEM de abrangência, em pontos, dos SUPORTES e RESISTÊNCIAS
input bool               InpUseFilterSUPORTEeRESISTENCIA = true;                //--- Usar SUPORTEeRESISTENCIA (Sim=true/Não=false)
input double             InputMargemSUPORTEeRESISTENCIA  = 0.0;                 //--- MARGEM de abrangência, dos SUPORTES e RESISTÊNCIAS
input int                InputTotalSUPORTEeRESISTENCIA   = 30;                  //--- Quantidade de dias de coleta dos SUPORTES e RESISTÊNCIAS
input string             InputSymbolSUPORTEeRESISTENCIA  = "WIN$N";             //--- "WDO$" para Mini Dólar e "WIN$" para Mini Índice
input double             InputMargemGatilhoSR            = 10;                  //--- Margem Gatilho SUPORTE E RESISTÊNCIA
//--- Parâmetros LTA e LTB
input bool               InpUseFilterLT                  = true;                //--- Usar LT (Sim=true/Não=false)
input double             InputMinimoAngular              = 20.0;                //--- Ângulo mínimo PARÂMETRO LTA E LTB
input int                InputQuantidadeLT               = 4;                   //--- Quantidade de LTAs e LTBs podem ser cumuladas no gráfico
input double             InputMargemLT                   = 10.0;                //--- MARGEM de abrangência, das LTAs e LTBs
//--- 
//--- input int          InputDiaAnterior                = 1;                   //---
input int                InputDiasAnteriores             = 1;                   //--- ainda não está sendo usado no indBruno
//--- 
//--- input group "###### - Gerenciamento Notificações - ######"
input bool               inpHabMsg                       = true;                //--- Habilitar impressão/print de mensagens
//--- 
//+------------------------------------------------------------------+
//| Criação de objeto para TF FirstBar, renovação TF, PD e PD2       |
//+------------------------------------------------------------------+
//--- Entrada de parâmetros do MAX e MIN da primeira VELA
input string            InpName      = "Arrow";    // Nome do sinal
input int               InpDate      = 25;         // Ponto de ancoragem da data em %
input int               InpPrice     = 25;         // Ponto de ancoragem do preço em %
input ENUM_ARROW_ANCHOR InpAnchor    = ANCHOR_TOP; // Tipo de ancoragem
input color             InpColor     = clrRed;     // Cor do sinal
input ENUM_LINE_STYLE   InpStyle     = STYLE_DOT;  // Estilo da linha da borda
input int               InpWidth     = 1;          // Tamanho do sinal
input bool              InpBack      = false;      // Sinal do fundo
input bool              InpSelection = false;      // Destaque para mover
input bool              InpHidden    = true;       // Ocultar na lista de objetos
input long              InpZOrder    = 0;          // Prioridade para clicar no mouse
//+------------------------------------------------------------------+
//| VARIÁVEIS GLOBAIS                                                |
//+------------------------------------------------------------------+
//---
double indBufferTopos[];                     //--- ainda não está sendo usado no indBruno
double indBufferFundos[];                    //--- ainda não está sendo usado no indBruno
double indBufferSuportes[];                  //--- ainda não está sendo usado no indBruno
double indBufferResistencias[];              //--- ainda não está sendo usado no indBruno
double indBufferPullback[];                  //--- ainda não está sendo usado no indBruno
double indBufferDrawback[];                  //--- ainda não está sendo usado no indBruno
double indBufferPulbackSecundario[];         //--- ainda não está sendo usado no indBruno
double indBufferDrawbackSecundario[];        //--- ainda não está sendo usado no indBruno
double indBufferLTA[];                       //--- ainda não está sendo usado no indBruno
double indBufferLTB[];                       //--- ainda não está sendo usado no indBruno
double indBufferMaximaPrimeiroCandle[];      //--- ainda não está sendo usado no indBruno
double indBufferMinimaPrimeiroCandle[];      //--- ainda não está sendo usado no indBruno
//---
MqlRates Rates[]; 
//int copiedResistencia = 0;
//+------------------------------------------------------------------+
//| DECLARACAO Banco de Dados                                        |
//+------------------------------------------------------------------+
int db;
//+------------------------------------------------------------------+
//| DECLARACAO impressão de mensagens                                |
//+------------------------------------------------------------------+
string msg;
//+------------------------------------------------------------------+
//| FLAGS BOOLEANAS DAS FUNÇÕES ABAIXO                               |
//+------------------------------------------------------------------+
bool flagFCA = false; //--- Flag da Função ClearAll
bool flagFND = false; //--- Flag da Função NewDay
bool flagFCB = false; //--- Flag da Função CheckBottomTop
bool flagFFB = false; //--- Flag da Função FirstBar
//---
bool plotObj = false; //--- Armazena o estado inicial como false/falso/inválido //--- ainda não está sendo usado no indBruno
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit() {
//--- 
   ArraySetAsSeries(Rates,true);                                            //--- true significa ordem reversa de indexação. 
//--- indicator buffers mapping - a função nativa para esse fim é a SetIndexBuffer
//--- Buffers do tipo DATA
   SetIndexBuffer(0,indBufferTopos,INDICATOR_DATA);                         //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(1,indBufferFundos,INDICATOR_DATA);                        //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(2,indBufferSuportes,INDICATOR_DATA);                      //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(3,indBufferResistencias,INDICATOR_DATA);                  //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(4,indBufferPullback,INDICATOR_DATA);                      //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(5,indBufferDrawback,INDICATOR_DATA);                      //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(6,indBufferPulbackSecundario,INDICATOR_DATA);             //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(7,indBufferDrawbackSecundario,INDICATOR_DATA);            //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(8,indBufferLTA,INDICATOR_DATA);                           //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(9,indBufferLTB,INDICATOR_DATA);                           //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(10,indBufferMaximaPrimeiroCandle,INDICATOR_DATA);         //--- ainda não está sendo usado no indBruno
   SetIndexBuffer(11,indBufferMinimaPrimeiroCandle,INDICATOR_DATA);         //--- ainda não está sendo usado no indBruno
//---
// EventSetTimer(1); // Comentei, pois, aparentemente, não está sendo usado
//--- Reset dos arrays de dados do indicador
   ArrayInitialize(indBufferTopos,EMPTY_VALUE);                             //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferFundos,EMPTY_VALUE);                            //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferSuportes,EMPTY_VALUE);                          //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferResistencias,EMPTY_VALUE);                      //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferPullback,EMPTY_VALUE);                          //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferDrawback,EMPTY_VALUE);                          //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferPulbackSecundario,EMPTY_VALUE);                 //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferDrawbackSecundario,EMPTY_VALUE);                //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferLTA,EMPTY_VALUE);                               //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferLTB,EMPTY_VALUE);                               //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferMaximaPrimeiroCandle,EMPTY_VALUE);              //--- ainda não está sendo usado no indBruno
   ArrayInitialize(indBufferMinimaPrimeiroCandle,EMPTY_VALUE);              //--- ainda não está sendo usado no indBruno
   //--- Inicialização bem sucedida.
   return(INIT_SUCCEEDED);                                              
}
//+------------------------------------------------------------------+
//|  Função chamada durante a desinicialização                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   //--- REMOVE TODOS OS OBJETOS A PARTIR DE UM GRáFICO ESPECíFICO
   //ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_UP);                             //--- InpName,-1,OBJ_ARROW_UP
   //ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_DOWN);                           //--- InpName,-1,OBJ_ARROW_DOWN
   //ObjectsDeleteAll(0,"suporte",-1,OBJ_HLINE);                              //--- "suporte",-1,OBJ_HLINE
   //ObjectsDeleteAll(0,"resistencia",-1,OBJ_HLINE);                          //--- "resistencia",-1,OBJ_HLINE
   //---
   //EventKillTimer(); // Comentei, pois, aparentemente, não está sendo usado
   //---
}
//+------------------------------------------------------------------+
//| Função On Calculate para iteração de Indicador Customizado       |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,                                      //--- Tamanho do array price[] - total de barras no gráfico 
                const int prev_calculated,                                  //--- Barras tratadas na chamada anterior 
                const datetime & time[],                                    //--- Hora
                const double   & open[],                                    //--- Abertura
                const double   & high[],                                    //--- Máxima
                const double   & low[],                                     //--- Mínima
                const double   & close[],                                   //--- Fechamento
                const long     & tick_volume[],                             //--- Volume de Tick
                const long     & volume[],                                  //--- Volume Real
                const int      & spread[]) {                                //--- Spread
   //--- ABERTURA DE NOVA VELA
   if(prev_calculated != rates_total && prev_calculated > 0) {           
      //--- ESPECIFICAR MOMNETO DE UM NOVO DIA
      string bar1Day = StringSubstr(TimeToString(time[rates_total-3]),8,2); //--- 2022.10.17 - Barra 1 de 3
      string bar2Day = StringSubstr(TimeToString(time[rates_total-2]),8,2); //--- 2022.10.17 - Barra 2 de 3
      string bar3Day = StringSubstr(TimeToString(time[rates_total-1]),8,2); //--- 2022.10.18 - Barra 3 de 3 
      if(bar1Day==bar2Day&&bar2Day!=bar3Day) {
         //---
         //flagFCA = false;
         flagFND = false;
         flagFCB = false;
         //---
      //--- ABERTURA DA SEGUNDA VELA/BARRA DO DIA
      } else if(bar1Day!=bar2Day&&bar2Day==bar3Day) {
         //--- Se flagFCA estiver "false", então, chama-se a FuncaoClearAll - função para limpar a estrutura e DB  
         if(!flagFCA) FuncaoClearAll();  // if(!flagFCA)                      
         //--- Se flagFND for "false", então, chama-se a NewDay, para a coleta das informações respectivas         
         if(!flagFND) NewDay(rates_total, rates_total - 1, time, open, high, low, close); //if(!flagFND) 
         //--- Se CheckBottomTop for "true", então, tem-se a coleta das informações respectivas 
         if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){  
            //---
            // FALTA FAZER A VERIFICAÇÃO DE QUANDO ABRE UM NOVO DIA, DEPOIS DE JÁ TER COLOCADO O INDICADOR NO GRÁFICO
            //---
         }         
         //---
        //--- ABERTURA "A PARTIR" DA TERCEIRA VELA DO DIA
      } else if(bar1Day==bar2Day&&bar2Day==bar3Day) {
         //--- Se flagFCA estiver "false", então, chama-se a FuncaoClearAll - função para limpar a estrutura e DB 
         if(!flagFCA) FuncaoClearAll(); // 
         //--- Se flagFND for "false", então, chama-se a NewDay, para a coleta das informações respectivas      
         if(!flagFND) NewDay(rates_total, rates_total - 1, time, open, high, low, close);// 
         //--- Se CheckBottomTop for "false"
         if(flagFCB) {
            //--- chama-se a FuncaoFirstBar, para a coleta das informações respectivas 
            int firstbar = FuncaoFirstBar(1, rates_total, rates_total-1, time, open, high, low, close);
            msg = StringFormat ("firstbar: %d, time[firstbar] =  %s",
                                firstbar, TimeToString(time[firstbar],TIME_DATE|TIME_SECONDS));  
            FuncaoPrint (msg);      
            //---
            for(int i=firstbar;i<rates_total;i++) {
               //---
               if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){
                  //---
                  
                  //---
               }         
               //---
            }
            //---
            flagFCB = true;
            //---
         } else {
            //---
            if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){
               //---
               
               //---
            }         
            //---             
         }
    
      }
   //novo tick
   } else if(prev_calculated == rates_total) { 
      //---
      if(!flagFCA) return(rates_total);
      //---         
      if(!flagFND) return(rates_total);
      //---
      if(!flagFCB) return(rates_total);
      //---
      if(CheckBottomTopTick(rates_total, rates_total - 1, time, open, high, low, close)) {
      }         
   }  //---
   //--- return value of prev_calculated for next call
   return(rates_total);
}
//+------------------------------------------------------------------+
//|          Função Clear All                                        |
//+------------------------------------------------------------------+
void FuncaoClearAll() {
   //--- REMOVE TODOS OS OBJETOS A PARTIR DE UM GRáFICO ESPECíFICO --- CLEAR MEM SETUP AND DBS
   //ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_UP);                         //--- InpName,-1,OBJ_ARROW_UP
   //ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_DOWN);                       //--- InpName,-1,OBJ_ARROW_DOWN
   //ObjectsDeleteAll(0,"suporte",-1,OBJ_HLINE);                          //--- "suporte",-1,OBJ_HLINE
   //ObjectsDeleteAll(0,"resistencia",-1,OBJ_HLINE);                      //--- "resistencia",-1,OBJ_HLINE
   //--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO.
   ChartRedraw();      
   //--- FLAGs da FuncaoClearAll (flagFCA)
   flagFCA = true;
   //--- RESETAR/ZERAR SETUP
   //--- PRIMEIRA BARRA DO DIA
   setup.highFirstBar               = 0;
   setup.lowFirstBar                = 0;
   setup.distFirstBar               = 0;
   setup.topo                       = 0;
   setup.fundo                      = 0;
   setup.firstBar                   = 0;
   setup.memFirstBar                = true; 
   //--- TOPOS e FUNDOS   
   setup.gatilhoFundoPrecoTFdt      = 0;
   setup.gatilhoFundoPrecoTF        = 0;
   setup.gatilhoFundoMaxTF          = 0;
   setup.gatilhoFundoTF             = false;
   setup.gatilhoTopoPrecoTFdt       = 0;
   setup.gatilhoTopoPrecoTF         = 0;
   setup.gatilhoTopoMinTF           = 0;
   setup.gatilhoTopoTF              = false;
   //--- SUPORTES e RESISTÊNCIAS   
   setup.gatilhoFundoPrecoSRdt      = 0; 
   setup.gatilhoFundoPrecoSR        = 0;
   setup.gatilhoFundoMaxSR          = 0;
   setup.gatilhoFundoSR             = false;
   setup.gatilhoTopoPrecoSRdt       = 0;
   setup.gatilhoTopoPrecoSR         = 0;
   setup.gatilhoTopoMinSR           = 0;
   setup.gatilhoTopoSR              = false;
   //--- PULLBACK e DRAWBACK  
   setup.gatilhoFundoPrecoPDdt      = 0;
   setup.gatilhoFundoPrecoPD        = 0;
   setup.gatilhoFundoMaxPD          = 0;
   setup.gatilhoFundoPD             = false;
   setup.gatilhoTopoPrecoPDdt       = 0;
   setup.gatilhoTopoPrecoPD         = 0;
   setup.gatilhoTopoMinPD           = 0;
   setup.gatilhoTopoPD              = false;    
   ArrayFree(setup.drawback);
   ArrayFree(setup.pullback);
   //--- PULLBACK2 (SECUNDÁRIO) e DRAWBACK2 (SECUNDÁRIO)
   setup.gatilhoFundoPrecoPD2dt      = 0; 
   setup.gatilhoFundoPrecoPD2        = 0;
   setup.gatilhoFundoMaxPD2          = 0;
   setup.gatilhoFundoPD2             = false;
   setup.gatilhoTopoPrecoPD2dt       = 0;
   setup.gatilhoTopoPrecoPD2         = 0;
   setup.gatilhoTopoMinPD2           = 0;
   setup.gatilhoTopoPD2              = false;     
   ArrayFree(setup.drawback2);        
   ArrayFree(setup.pullback2);   

   //--- LTA - LINHA DE TENDÊNCIA DE ALTA e LTB - LINHA DE TENDÊNCIA DE BAIXA

   //--- Chamada da FUNÇÃO CreateDataBase - tabelas de dados DB
   CreateDataBase();
   //---
}
//+------------------------------------------------------------------+
//|                    Função New Day                                |
//+------------------------------------------------------------------+
void NewDay(const int rt,                       //--- Tamanho do array - total de barras no gráfico
            const int k,                        //--- Barras tratadas na chamada anterior
            const datetime & time[],            //--- Hora
            const double   & open[],            //--- Abertura
            const double   & high[],            //--- Máxima
            const double   & low[],             //--- Mínima
            const double   & close[]) {         //--- Fechamento
            
   //--- FLAG da função NewDay atribuída como true/verdadeiro/válido. 
   flagFND = true;            
   //--- Alimenta a variável firstbar com os elementos da FuncaoFirstBar
   int firstbar = FuncaoFirstBar(1, rt, k, time, open, high, low, close);
   //--- Alimenta a variável do tipo setup.
   setup.highFirstBar = high[firstbar];                           //--- com a MáXIMA da primeira vela do dia
   setup.lowFirstBar  = low[firstbar];                            //--- com a MíNIMA da primeira vela do dia
   setup.distFirstBar = setup.highFirstBar - setup.lowFirstBar;   //--- com a diferença entre a máxima e a mínima da primeira vela do dia         
   //---
   // pensar no tratamento de erro caso encontra uma vela // com maxima menor do que low, ou seja, setup.distFirstBar < 0;
   
   //--- CRIA o NOME do sinal que será plotado no gráfico
   string name = InpName + "_Up_" + string(ulong(time[firstbar]));
   //--- CRIA plotagem de sinal ARROW UP no gráfico
   //if(plotObj) {
      if(!ArrowCreate(0, name, 0, time[firstbar], setup.highFirstBar, ANCHOR_TOP, OBJ_ARROW_UP, InpColor,
                   InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
         return;
      }
      name = InpName + "_Down_" + string(ulong(time[firstbar]));
      //--- CRIA plotagem de sinal ARROW DOWN no gráfico
      if(!ArrowCreate(0, name, 0, time[firstbar], setup.lowFirstBar, ANCHOR_BOTTOM, OBJ_ARROW_DOWN,InpColor,
                      InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
         //--- FLAG da plotObj atribuída como false/falso/inválido             
         //plotObj = false;
         return; 
      }
     //}//--- FIM if(plotObj)
   
   //--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO.
   ChartRedraw();
   //---
   FuncaoSuporteResistencia(close[k-1]); //--- aqui estava k, adicinei k-1 - verificar se está correta a correção
   //---   
}
//+------------------------------------------------------------------+
//| FUNÇÃO ON TIMER                                                  |
//+------------------------------------------------------------------+
void OnTimer(void) { //--- AINDA NÃO ESTÁ SENDO USADA NO indBruno
   
}
//+------------------------------------------------------------------+
//| FUNÇÃO SUPORTES E RESISTÊNCIAS                                   |
//+------------------------------------------------------------------+
void  FuncaoSuporteResistencia(double price_ref) {
   //---
   int cont = 0, copiedSuporteResistencia = 0;
   //--- achar o metodo que retorna a quantidade maxima de velas disponiveis (TERMINAL_MAXBARS?)?
   //---
   copiedSuporteResistencia=CopyRates(InputSymbolSUPORTEeRESISTENCIA,PERIOD_D1,1,TERMINAL_MAXBARS,Rates);
   //copiedResistencia=CopyRates(InputSymbolSUPORTEeRESISTENCIA,PERIOD_D1,1,InputTotalSUPORTEeRESISTENCIA,Rates);
   //--- SE A VARIÁVEL "copiedSuporteResistencia" TÊM DADOS
   if(copiedSuporteResistencia>0) {
      //--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA SUPORTE
      for(int i=0;i<copiedSuporteResistencia;i++) {
         //--- SE COTAÇÃO DAS [i] MÍNIMAS SÃO MENORES DO QUE O PREÇO DE REFERÊNCIA
         if(Rates[i].low < price_ref) {
            //--- INSERE-SE NA TABELA "SUPORTE" OS DADOS DOS SUPORTES - MÍNIMAS DOS DIAS ANTEIRIORES
            if(InsertTable(db,"SUPORTE",Rates[i].low,Rates[i].time,ulong(Rates[i].time))) cont++;            
            //--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
            string name = "suporte_"+(string)i;
            //--- CRIA UMA LINHA HORIZONTAL DE SUPORTE
            if(!HLineCreate(0,name,0,Rates[i].low,clrRed,InpStyle,InpWidth,InpBack, 
               InpSelection,InpHidden,InpZOrder)) { 
               return; 
            }            
            //---
         }
         //--- SE O CONTADOR É MAIOR OU IGUAL AO VALOR DO INPUT, ENTÃO, DEVE PARAR O LAÇO DE REPETIÇÃO PARA ENCONTRAR OS SUPORTES
         if(cont>=InputTotalSUPORTEeRESISTENCIA) break;
         //---
       }
     } else {
      //--- SENÃO, ENVIO DE MENSAGEM DE POSSÍVEL ERRO "copiedSuporteResistencia"
      msg = StringFormat ("%s - Possivel erro! Copied = %d;",
                          __FUNCTION__,copiedSuporteResistencia);
      FuncaoPrint(msg);
      //---
    }
    cont = 0;
   //--- SE A VARIÁVEL "copiedSuporteResistencia" TÊM DADOS
   if(copiedSuporteResistencia>0) {
      //--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA SUPORTE
      for(int i=0;i<copiedSuporteResistencia;i++) {
         //--- SE COTAÇÃO DAS [i] MÁXIMAS SÃO MAIORES DO QUE O PREÇO DE REFERÊNCIA
         if(Rates[i].high > price_ref) {
            //--- INSERE-SE NA TABELA "RESISTENCIA" OS DADOS DAS RESISTÊNCIAS - MÁXIMAS DOS DIAS ANTEIRIORES
            if(InsertTable(db,"RESISTENCIA",Rates[i].high,Rates[i].time,ulong(Rates[i].time))) cont++;
            //--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
            string name = "resistencia_"+(string)i;
            //--- CRIA UMA LINHA HORIZONTAL DE RESISTÊNCIA
            if(!HLineCreate(0,name,0,Rates[i].high,clrGreenYellow,InpStyle,InpWidth,InpBack, 
               InpSelection,InpHidden,InpZOrder)) { 
               return; 
            }            
            //---
         }
         //--- SE O CONTADOR É MAIOR OU IGUAL AO VALOR DO INPUT, ENTÃO, DEVE PARAR O LAÇO DE REPETIÇÃO - SUPORTES
         if(cont>=InputTotalSUPORTEeRESISTENCIA) break;
         //---
      
       }                 
     } else {
      //--- SENÃO, ENVIO DE MENSAGEM DE POSSÍVEL ERRO "copiedSuporteResistencia"
      msg = StringFormat("%s - Possivel erro! Copied = %d;",
                         __FUNCTION__,copiedSuporteResistencia);
      FuncaoPrint(msg);
      //---
   }
   //--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO. 
   ChartRedraw();    
   //---
 }
//+------------------------------------------------------------------+
//|               FUNÇÃO PRIMEIRA BARRA DO DIA                       |
//+------------------------------------------------------------------+
int FuncaoFirstBar(int diaAnterior,                   //--- Dia anterior - para encontrar a primeira barra do dia posterior
                   const int rt,                      //--- Tamanho do array - total de barras no gráfico
                   const int k,                       //--- Barras tratadas na chamada anterior
                   const datetime & time[],           //--- Hora
                   const double   & open[],           //--- Abertura
                   const double   & high[],           //--- Máxima
                   const double   & low[],            //--- Mínima
                   const double   & close[]) {        //--- Fechamento
   flagFFB = true;
   //---
   /*
   dia 144500 03/10/2022 seg REF
   dia 144499 02/10/2022 dom OBS NAO TEM DADO
   dia 144498 01/10/2022 sab OBS NAO TEM DADO
   dia 144497 30/09/2022 sex
   dia 144496 29/09/2022 qui
   dia 144495 28/09/2022 qua
   dia 144494 27/09/2022 ter objetivo **** primeira vela do dia em questao
   dia 144493 26/09/2022 seg ******* ultima vela do dia anterior
   */
   //--- INICIA-SE COM AS VARIÁVEIS DESIGNADAS COMO ZERO
   int firstbar = 0, contDay = 0;
   //--- 1º, foi armazenado na variável dayRef, ao dividir time[rt - 1] por 86400 = dias / 2º, normalização do time (milisegundos) para dias = divisão por 86400 = DIA
   ulong dayRef = time[rt - 1] / 86400, dayCont = time[rt - 1] / 86400; 
   //--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA rt-1 (última barra fechada) com indexador decrescente
   for(int i = rt - 1; i >= 1; i--) {
      //--- É atribuído à variável dayRef a informação do Dia de referência
      dayRef = time[i] / 86400;
      //--- Se, o dia de referência é diferente de dayCount
      if (dayRef != dayCont) {
         //--- Será indexado o acréscimo à counDay até que dayCont seja = a dayRef
         contDay++;
         dayCont = dayRef;
      }
      //--- SE contDay FOR MAIOR OU IGUAL AO diaAnterior
      if(contDay >= diaAnterior) {
         //--- É ATRIBUÍDO À VARIÁVEL firstbar O VALOR DE [i] +1, pois se trata da primeira barra do dia
         firstbar = i + 1;
         //--- O operador break finaliza a execução do operador for mais próximo
         break; 
         //---
      }
      //--- FIM do for(int i = rt - 1; i >= 1; i--) 
   }
   //--- O operador return finaliza a execução da função corrente e retorna o valor da variável firstbar 
   return firstbar;
}
//+---------------------------------------------------------------------+
//| FUNÇÃO CheckBottomTopTick - MERCADO ABERTO - PRESENTE - A CADA TICK |
//+---------------------------------------------------------------------+
bool CheckBottomTopTick(const int rt,                      //--- Tamanho do array - total de barras no gráfico
                        const int k,                       //--- Barras tratadas a cada tick
                        const datetime & time[],           //--- Hora
                        const double   & open[],           //--- Abertura
                        const double   & high[],           //--- Máxima
                        const double   & low[],            //--- Mínima
                        const double   & close[]) {        //--- Fechamento
   //---
   return false;
   //---
}
//+---------------------------------------------------------------------+
//| FUNÇÃO CheckBottomTop - PARA O PASSADO - BARRA FECHADA              |
//+---------------------------------------------------------------------+
bool CheckBottomTop(const int rt,                          //--- Tamanho do array - total de barras no gráfico
                    const int k,                           //--- Barras tratadas na chamada anterior
                    const datetime & time[],               //--- Hora
                    const double   & open[],               //--- Abertura
                    const double   & high[],               //--- Máxima
                    const double   & low[],                //--- Mínima
                    const double   & close[]) {            //--- Fechamento
   
   //--- FLAG da Função CheckBottomTop - flagFCB - ATIVADA PARA TRUE
   flagFCB = true;
   //--- Ainda estou olhando pra primeira vela
   if(setup.memFirstBar == true) { 
      //--- NÃO TEM FUNDO e NÃO TEM TOPO DEFINIDOS
      if(setup.fundo == 0 && setup.topo == 0) { 
         //--- DEFINIU-SE O FUNDO NA MÍNIMA DA 1ª BARRA (VELA ANTERIOR K-1)
         setup.fundo = low[k-1];
         indBufferFundos[k-1] = setup.fundo;
         //--- DEFINIU-SE O TOPO NA MÁXIMA DA 1ª BARRA (VELA ANTERIOR K-1)                
         setup.topo  = high[k-1];               
         //--- ARMAZENA-SE O ÚLTIMO TOPO REGISTRADO, NA TABELA TOPOS.
         InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1])); 
         //--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS.
         InsertTable(db,"FUNDOS",low[k-1],time[k-1],ulong(time[k-1])); 
        //--- SE TEM FUNDO DEFINIDO e TOPO DEFINIDO
      } else if(setup.fundo>0 && setup.topo>0) {
                //--- SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
                //--- RENOVAÇÃO DE TOPO / PRIMEIRA BARRA DO DIA - GATILHO
                if(close[k-2] >= setup.highFirstBar + InputMaiorQ1CandledoDia &&
                    high[k-2] >= high[k-1]) {
                //--- ATUALIZAÇÃO DAS MEMÓRIAS DAS VARIÁVEIS DA STRUCT BASE_DADOS
                setup.gatilhoTopoTF        = true;
                setup.gatilhoTopoPrecoTF   = high[k-2];
                setup.gatilhoTopoMinTF     = low[k-2];
                setup.gatilhoTopoPrecoTFdt = time[k-2];
              //--- RENOVAÇÃO DE TOPO / PRIMEIRA BARRA DO DIA - CONFIRMACAO
              } //--- SENÃO, SE GATILHOTF É VÁLIDO/VERDADEIRO E FECHAMENTO DA BARRA ANTERIOR SOMADO AO INPUT FOR MENOR QUE A MÍNIMA DO CANDLE GATILHO
                else if(setup.gatilhoTopoTF && 
                       (close[k-1] + InputMargemGatilhoTF <= setup.gatilhoTopoMinTF)) {
                //--- LOGO, NÃO TEM FUNDO VIGENTE, PORTANTO, -1;
                setup.fundo = -1;
                //--- TEM-SE UM NOVO TOPO, IDENTIFICADO PELO PREÇO DA MÁXIMA DO CANDLE GATILHO - SITUAÇÃO DE RENOVAÇÃO DE TOPO
                setup.topo  = setup.gatilhoTopoPrecoTF;
                //--- ARMAZENA-SE O ÚLTIMO TOPO REGISTRADO, NA TABELA TOPOS
                InsertTable(db,"TOPOS",setup.gatilhoTopoPrecoTF,setup.gatilhoTopoPrecoTFdt,ulong(setup.gatilhoTopoPrecoTFdt));
                //--- NÃO ESTÁ MAIS "OLHANDO" PARA A PRIMEIRA BARRA DO DIA         
                setup.memFirstBar = false;
                //--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
                string name = InpName + "_RENOVAÇÃO-TOPO-1BARRA_" + string(ulong(setup.gatilhoTopoPrecoTFdt));
                //--- CRIA sinal ARROW UP no gráfico - NOVO TOPO
                
                if(!ArrowCreate(0, name, 0, setup.gatilhoTopoPrecoTFdt, setup.topo, ANCHOR_TOP, OBJ_ARROW_UP, InpColor,
                                InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
                //--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
                msg = StringFormat("ArrowCreate Failed %s as %s - Topo atual = %.2f;",
                                   name,TimeToString(setup.gatilhoTopoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.topo);
                FuncaoPrint(msg);
               
                //---RESETAR/ZERAR GATILHOS
                setup.gatilhoTopoTF        = false;
                setup.gatilhoTopoPrecoTF   = 0;
                setup.gatilhoTopoMinTF     = 0; 
                setup.gatilhoTopoPrecoTFdt = 0;
               //--- FIM CRIAÇÃO DE OBJETO E PRINT
               } else     
                 //--- ENVIO DE PRINT DA RENOVAÇÃO DE TOPO EM RELAÇÃO À PRIMEIRA BARRA DO DIA
                 msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE TOPO: Topo atual = %.2f;",
                                     __FUNCTION__,TimeToString(setup.gatilhoTopoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.topo);
                 FuncaoPrint(msg);
                 //--- 
               //--- FIM SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
            } 
               //--- SITUAÇÃO DE RENOVAÇÃO DE FUNDO - PRIMEIRA BARRA DO DIA
               //--- RENOVAÇÃO DE FUNDO / PRIMEIRA BARRA DO DIA - GATILHO
                else if(close[k-2] <= setup.lowFirstBar - InputMaiorQ1CandledoDia &&
                          low[k-2] <= high[k-1]) {
                //--- ATUALIZAÇÃO DAS MEMÓRIAS DAS VARIÁVEIS DA STRUCT BASE_DADOS
                setup.gatilhoFundoTF        = true;
                setup.gatilhoFundoPrecoTF   = low[k-2];
                setup.gatilhoFundoMaxTF     = high[k-2];
                setup.gatilhoFundoPrecoTFdt = time[k-2];
              //--- RENOVAÇÃO DE FUNDO / PRIMEIRA BARRA DO DIA - CONFIRMACAO
              } //--- SENÃO, SE GATILHOTF É VÁLIDO/VERDADEIRO E FECHAMENTO DA BARRA ANTERIOR SUTRAÍDO PELO INPUT FOR MENOR QUE A MáXIMA DO CANDLE GATILHO
                else if(setup.gatilhoFundoTF && 
                       (close[k-1] - InputMargemGatilhoTF >= setup.gatilhoFundoMaxTF)) {
                //--- LOGO, NÃO TEM TOPO VIGENTE, PORTANTO, -1;
                setup.topo = -1;
                //--- TEM-SE UM NOVO FUNDO, IDENTIFICADO PELO PREÇO DA MÍNIMA DO CANDLE GATILHO - SITUAÇÃO DE RENOVAÇÃO DE FUNDO
                setup.fundo  = setup.gatilhoFundoPrecoTF;
                //--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS
                InsertTable(db,"FUNDOS",setup.gatilhoFundoPrecoTF,setup.gatilhoFundoPrecoTFdt,ulong(setup.gatilhoFundoPrecoTFdt));
                //--- NÃO ESTÁ MAIS "OLHANDO" PARA A PRIMEIRA BARRA DO DIA         
                setup.memFirstBar = false;
                //--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
                string name = InpName + "_RENOVAÇÃO-FUNDO-1BARRA_" + string(ulong(setup.gatilhoFundoPrecoTFdt));
                //--- CRIA sinal ARROW DOWN no gráfico - NOVO FUNDO
                if(!ArrowCreate(0, name, 0, setup.gatilhoFundoPrecoTFdt, setup.fundo, ANCHOR_BOTTOM, OBJ_ARROW_DOWN, InpColor,
                                InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
                //--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
                msg = StringFormat("ArrowCreate Failed %s as %s - Fundo atual = %.2f;",
                                   name,TimeToString(setup.gatilhoFundoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.fundo);
                FuncaoPrint(msg);
               
                //---RESETAR/ZERAR GATILHOS
                setup.gatilhoFundoTF        = false;
                setup.gatilhoFundoPrecoTF   = 0;
                setup.gatilhoFundoMaxTF     = 0; 
                setup.gatilhoFundoPrecoTFdt = 0;
               //--- FIM CRIAÇÃO DE OBJETO E PRINT
               } else     
                 //--- ENVIO DE PRINT DA RENOVAÇÃO DE FUNDO EM RELAÇÃO À PRIMEIRA BARRA DO DIA
                 msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE FUNDO: Fundo atual = %.2f;",
                                     __FUNCTION__,TimeToString(setup.gatilhoFundoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.fundo);
                 FuncaoPrint(msg);
                 //--- 
               //--- FIM SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
            }        
      } //--- FIM else if(setup.fundo>0 && setup.topo>0)
   } //--- FIM if(setup.memFirstBar == true) 
     //--- NAO estou olhando mais para a primeira vela
     else if(setup.memFirstBar == false) { 
      //---
      if(InpUseFilterTopoFundo) {
         //--- EXISTE UM FUNDO DEFINIDO
         if (setup.fundo>0 && setup.topo<0) {
             //--- CRITÉRIOS DE RENOVAÇÃO DE FUNDO - FILTRO TOPO E FUNDO 
             //--- SE A MÍNIMA DA PENÚLTIMA VELA (K-2) FOR MENOR OU IGUAL QUE O FUNDO VIGENTE E
             if((low[k-2] <= setup.fundo) &&
                //--- E O FECHAMENTO DA ÚLTIMA VELA (K-1) SUBTRAÍDO PELO InputMargemGatilhoTF FOR MAIOR OU IGUAL QUE ABERTURA E FECHAMENTO DA PENÚLTIMA VELA (K-2)
                (close [k-1] - InputMargemGatilhoTF >= open [k-2] && close [k-1] - InputMargemGatilhoTF >= close [k-2])) {
                //--- TEM-SE UM NOVO FUNDO, IDENTIFICADO PELA MÍNIMA DA PENÚLTIMA BARRA FECHADA (K-2) - SITUAÇÃO DE RENOVAÇÃO DE FUNDO 
                setup.fundo = low[k-2];   
                //--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS
                InsertTable(db,"FUNDOS",low[k-2],time[k-2],ulong(time[k-2]));
                //--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
                string name = InpName + "_FundoRENOVAÇÃOTF_" + string(ulong(time[k-2]));
                //--- CRIA sinal ARROW DOWN no gráfico - NOVO FUNDO
                if(!ArrowCreate(0, name, 0, time[k-2], setup.fundo, ANCHOR_BOTTOM, OBJ_ARROW_DOWN, InpColor,
                                InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
                //--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
                msg = StringFormat("%s - %s - VELAS SEGUINTES TF - RENOVACAO DE FUNDO TF: Fundo atual = %.2f; low = %.2f;",
                                   __FUNCTION__,TimeToString(time[k-2],TIME_DATE|TIME_SECONDS),setup.fundo,low[k-2]);                
                FuncaoPrint(msg);
                  
             } 
                //--- ENVIO DE PRINT DA RENOVAÇÃO DE FUNDO EM RELAÇÃO AO FILTRO TOPO E FUNDO      
                msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE FUNDO TF: Fundo atual = %.2f;",
                                   __FUNCTION__,TimeToString(time[k-2],TIME_DATE|TIME_SECONDS),setup.fundo);
                FuncaoPrint(msg); 
                //--- FIM CRIAÇÃO DE OBJETO E PRINT EM RELAÇÃO AO FILTRO TOPO E FUNDO 
            //--- critérios/requisitos para inversão de FUNDO para TOPO - GATILHO
            } else if(high[k-1] - setup.fundo >= InpFilterTopoFundo) {
               //---
               setup.gatilhoTopoTF      = true;
               setup.gatilhoTopoPrecoTF = high[k-1];
               setup.gatilhoTopoMinTF   = low[k-1];
            //--- critérios/requisitos para inversão de FUNDO para TOPO - CONFIRMACAO
            } else if(setup.gatilhoTopoTF && 
                      (close[k-1] - InputMargemGatilhoTF <= setup.gatilhoTopoMinTF)) {
               //---
               setup.fundo = -1;
               setup.topo  = setup.gatilhoTopoPrecoTF;
               //---
               InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1]));
               //---RESETAR/ZERAR GATILHOS
               setup.gatilhoTopoTF      = false;
               setup.gatilhoTopoPrecoTF = 0;
               setup.gatilhoTopoMinTF   = 0;
               //---
            }    
         } //--- FIM DE "EXISTE UM FUNDO DEFINIDO" 
         //---
           //--- EXISTE UM TOPO DEFINIDO
           else if (setup.fundo<0 && setup.topo>0) { 
            //--- critérios para renovação de topo
            if(setup.topo < high[k-1]) {
               //---
               setup.topo = high[k-1]; //--- Atualiza o topo
               //---
               InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1]));
               //---
               msg = StringFormat("%s - %s - VELAS SEGUINTES TF - POSSIVEL RENOVACAO DE TOPO: Topo atual = %.2f; high = %.2f;",
                                  __FUNCTION__,TimeToString(time[k-1],TIME_DATE|TIME_SECONDS),setup.fundo,high[k-1]);                
               FuncaoPrint(msg);
            //--- critérios/requisitos para inversão de TOPO para FUNDO - GATILHO
            } else if(setup.topo - low[k-1] >= InpFilterTopoFundo ){
               //---
               setup.gatilhoFundoTF      = true;
               setup.gatilhoFundoPrecoTF = low[k-1];
               setup.gatilhoFundoMaxTF   = high[k-1];
               setup.gatilhoFundoPrecoTFdt = time[k-1];
            //--- critérios/requisitos para inversão de TOPO para FUNDO - CONFIRMACAO
            } else if(setup.gatilhoFundoTF && 
                      (close[k-1] + InputMargemGatilhoTF >= setup.gatilhoFundoMaxTF)) {
               //---
               setup.topo = -1;
               setup.fundo = setup.gatilhoFundoPrecoTF;
               //---
               InsertTable(db,"FUNDOS",low[k-1],time[k-1],ulong(time[k-1]));
               //---RESETAR/ZERAR GATILHOS
               setup.gatilhoFundoTF      = false;
               setup.gatilhoFundoPrecoTF = 0;
               setup.gatilhoFundoMaxTF   = 0;
               setup.gatilhoFundoPrecoTFdt = 0;
               //---
            }
         } //--- FIM de "EXISTE UM TOPO DEFINIDO"
      } //--- END if(InpUseFilterTopoFundo) {
      //Usar Distância PullBack (Sim=true/Não=false)
      if(InpUseFilterDistanciaPullBack) {
         //---
         double result_dist[]; //--- ************
         string result[];      //--- Um array para obter strings 
         string sep = "|";     //--- Um separador como um caractere 
         ushort u_sep;         //--- O código do caractere separador 
         u_sep = StringGetCharacter(sep,0); //--- Obtém o código do separador 
         int retorno = StringSplit(InpFilterDistanciaPullBack,u_sep,result);
         //---
         if(ArrayResize(result_dist,retorno)==retorno) {
            //---
            for(int i=0;i<retorno;i++) result_dist[i] = StringToDouble(result[i])/100;
            //---
         } else return false;
         //---
         int total = ArraySize(result_dist);
         //---
         double dist = FuncaoReadDatabase(db,"FUNDOS") -  FuncaoReadDatabase(db,"TOPOS");
         //--- existe um fundo definido
         if (setup.fundo>0 && setup.topo<0) {
            //---
            for(int i=0;i<total;i++) {
               //---
               double drawback = setup.fundo + (result_dist[i] * dist);
               //--- critérios para DRAWBACK - GATILHO
               if((high[k-1] >= drawback - InputMargemGatilhoSR) && (high[k-1] <= drawback + InputMargemGatilhoSR)) {
                  //---
                  setup.gatilhoTopoPD      = true;
                  setup.gatilhoTopoPrecoPD = high[k-1];
                  setup.gatilhoTopoMinPD   = low[k-1];
               //--- critérios para DRAWBACK - CONFIRMACAO
               } else if(setup.gatilhoTopoPD && close[k-1] <= setup.gatilhoTopoMinPD - InputMargemGatilhoSR) {//*************************
                  //---
                  int total_db = ArraySize(setup.drawback);
                  if(ArrayResize(setup.drawback,total_db+1)==total_db+1) {
                     //---
                     setup.drawback[total_db] = setup.gatilhoTopoPrecoPD;
                     setup.gatilhoTopoPD      = false;
                     setup.gatilhoTopoPrecoPD = -1;
                     setup.gatilhoTopoMinPD   = -1;
                  }
               }
            //--- 
            }//END for(int i=0;i<total;i++) {
         //--- existe um topo definido
         } else if (setup.fundo<0 && setup.topo>0) {
            //---
            for(int i=0;i<total;i++) {
               //---
               double pullback = setup.topo - (result_dist[i] * dist);
               //--- critérios para PULLBACK - GATILHO
               if((low[k-1] <= pullback + InputMargemGatilhoSR) && (low[k-1] >= pullback - InputMargemGatilhoSR)) {
                  //---
                  setup.gatilhoFundoPD      = true;
                  setup.gatilhoFundoPrecoPD = low[k-1];
                  setup.gatilhoFundoMaxPD   = high[k-1];
               //--- critérios para DRAWBACK - CONFIRMACAO
               } else if(setup.gatilhoFundoPD && close[k-1] >= setup.gatilhoFundoMaxPD + InputMargemGatilhoSR) {//*************************
                  //---
                  int total_db = ArraySize(setup.pullback);
                  if(ArrayResize(setup.pullback,total_db+1)==total_db+1) {
                     //---
                     setup.pullback[total_db]  = setup.gatilhoFundoPrecoPD;
                     setup.gatilhoFundoPD      = false;
                     setup.gatilhoFundoPrecoPD = -1;
                     setup.gatilhoFundoMaxPD   = -1;
                  }
               }
            //--- 
            }//END for(int i=0;i<total;i++) {            
         }
         //---
      }//END if(InpUseFilterDistanciaPullBack) {
      //---
      if(InpUseFilterSUPORTEeRESISTENCIA) {
         //--- critérios para renovacao de topos e fundos - SUPORTE e RESISTENCIA
         if (setup.fundo>0 && setup.topo<0) {//--- existe um FUNDO definido
            //--- critérios renovação de FUNDOS - SUPORTE
            //--- criar uma funcao pra fazer um loop dentro do arrayMinD1 pra achar a min mais proxima dos suportes
            
            if(setup.fundo >= low[k-1] && FuncaoReadDataBaseRSMaisProximo(db,"SUPORTE",low[k-1]) && !setup.gatilhoFundoSR) {//--- avaliação: tem um FUNDO novo?
            //if(setup.fundo >= low[k-1] && FuncaoRSMaisProximo(low[k-1],arrayMinD1) && !setup.gatilhoFundoSR) {//--- avaliação: tem um FUNDO novo?
               //--- FUNÇÃO - PROVÁVEL FUNDO
               setup.gatilhoFundoSR      = true;        //--- Gatilho FUNDO que estava no estado "false", foi ativado para "true" - em razão de ser um provável FUNDO
               setup.gatilhoFundoPrecoSR = low[k-1];      //--- Provável novo FUNDO
               setup.gatilhoFundoMaxSR   = high[k-1];     //--- Máxima do Provável novo FUNDO - que deverá ser rompida pelo fechamento do candle posterior
               setup.gatilhoFundoPrecoSRdt = time[k-1];
               setup.gatilhoTopoSR       = false;
               setup.gatilhoTopoPrecoSR  = 0;
               //---
               printf("%s - %s - POSSIVEL RENOVACAO DE FUNDO: Fundo atual = %.2f; low = %.2f;",
                  __FUNCTION__,TimeToString(time[k-1],TIME_DATE|TIME_SECONDS),setup.fundo,low[k-1]);
               //---
               // && low[k-1]<=setup.gatilhoFundoPreco//--- InputMargemSUPORTEeRESISTENCIA
            } else if(setup.fundo >= low[k-1] && close[k-1]>setup.gatilhoFundoMaxSR + InputMargemGatilhoSR && setup.gatilhoFundoSR) { 
               //--- CONFIRMAçãO DE NOVO FUNDO
 
               //--- Atualização do Array de FUNDO
               setup.fundo = setup.gatilhoFundoPrecoSR; //--- Atualização da memória do FUNDO
               //---
               InsertTable(db,"FUNDOS",setup.fundo,setup.gatilhoFundoPrecoSRdt,ulong(setup.gatilhoFundoPrecoSRdt));
               //---  
               setup.gatilhoTopoSR       = false;
               setup.gatilhoTopoMinSR    = 0;               
               setup.gatilhoTopoPrecoSR  = 0;
               setup.gatilhoTopoPrecoSRdt = 0;
               setup.gatilhoFundoSR      = false;
               setup.gatilhoFundoMaxSR   = 0;
               setup.gatilhoFundoPrecoSR = 0;
               setup.gatilhoFundoPrecoSRdt = 0;
               //---
            //--- critérios inversao de  FUNDO para TOPO - RESISTÊNCIA
            } else if(high[k-1] > setup.fundo && 
               FuncaoReadDataBaseRSMaisProximo(db,"RESISTENCIA",high[k-1]) && 
               !setup.gatilhoTopoSR) {//--- já existe um FUNDO definido 
            //} else if(high[k-1] > setup.fundo && FuncaoRSMaisProximo(high[k-1],arrayMaxD1) && !setup.gatilhoTopoSR) {//--- já existe um FUNDO definido 
               //--- PROVÁVEL TOPO
               setup.gatilhoTopoSR      = true;         //--- Gatilho TOPO que estava no estado "false", foi ativado para "true" - em razão de ser um provável TOPO
               setup.gatilhoTopoPrecoSR = high[k-1];      //--- Provável novo TOPO
               setup.gatilhoTopoMinSR   = low[k-1];       //--- Mínima do Provável novo TOPO - que deverá ser rompida pelo fechamento do candle posterior
               setup.gatilhoTopoPrecoSRdt = time[k-1];
               setup.gatilhoFundoSR     = false;
               setup.gatilhoTopoPrecoSR = 0;
            //--- critérios inversao de  FUNDO para TOPO - RESISTÊNCIA
            } else if(high[k-1] > setup.fundo && 
               close[k-1]<setup.gatilhoTopoMinSR - InputMargemGatilhoSR  && 
               setup.gatilhoTopoSR) {//--- InputMargemSUPORTEeRESISTENCIA
               //--- CONFIRMAÇÃO DO NOVO TOPO
               setup.topo = setup.gatilhoTopoPrecoSR;   //--- Atualização do Array de TOPO
               //--- Atualização da memória do TOPO
               InsertTable(db,"TOPOS",setup.topo,setup.gatilhoTopoPrecoSRdt,ulong(setup.gatilhoTopoPrecoSRdt));
               //---                
               setup.fundo = -1;                        //--- FUNDO passa a ser negativo, em razão de ter confirmação de TOPO
               //---
               setup.gatilhoTopoSR       = false;
               setup.gatilhoTopoMinSR    = 0;               
               setup.gatilhoTopoPrecoSR  = 0;
               setup.gatilhoTopoPrecoSRdt = 0;
               setup.gatilhoFundoSR      = false;
               setup.gatilhoFundoMaxSR   = 0;
               setup.gatilhoFundoPrecoSR = 0;
               setup.gatilhoFundoPrecoSRdt = 0;
               //---
            }
         } else if (setup.fundo<0 && setup.topo>0) {//--- existe um TOPO definido
            //--- critérios renovação de TOPO - RESISTENCIA
            //--- avaliar a possibilidade de renovacao de topo
            
            if(high[k-1] >= setup.topo && 
               FuncaoReadDataBaseRSMaisProximo(db,"RESISTENCIA",high[k-1]) && 
               !setup.gatilhoTopoSR) {
            //if(high[k-1] >= setup.topo && FuncaoRSMaisProximo(high[k-1],arrayMaxD1) && !setup.gatilhoTopoSR) {
               //--- FUNÇÃO - PROVÁVEL TOPO
               setup.gatilhoTopoSR       = true;        //--- Gatilho TOPO que estava no estado "false", foi ativado para "true" - em razão de ser um provável TOPO
               setup.gatilhoTopoMinSR    = low[k-1];      //--- Mínima do Provável novo TOPO - que deverá ser rompida pelo fechamento do candle posterior           
               setup.gatilhoTopoPrecoSR  = high[k-1];     //--- Provável novo TOPO
               setup.gatilhoTopoPrecoSRdt  = time[k-1];
               setup.gatilhoFundoSR      = false;
               setup.gatilhoFundoMaxSR   = 0;
               setup.gatilhoFundoPrecoSR = 0;
               //---
            //--- confirmacao da renovacao de topo
            // && low[k-1]<=setup.gatilhoFundoPreco//--- InputMargemSUPORTEeRESISTENCIA
            } else if(high[k-1] >= setup.topo && 
               close[k-1]<setup.gatilhoTopoMinSR - InputMargemGatilhoSR && 
               setup.gatilhoTopoSR) { 
               //--- CONFIRMAçãO DE NOVO TOPO
               //--- Atualização do Array de TOPO
               InsertTable(db,"TOPOS",setup.topo,setup.gatilhoTopoPrecoSRdt,ulong(setup.gatilhoTopoPrecoSRdt));
               //---                
               setup.topo = setup.gatilhoTopoPrecoSR;   //--- Atualização da memória do TOPO
               //---
               setup.gatilhoTopoSR       = false;
               setup.gatilhoTopoMinSR    = 0;               
               setup.gatilhoTopoPrecoSR  = 0;
               setup.gatilhoTopoPrecoSRdt  = 0;
               setup.gatilhoFundoSR      = false;
               setup.gatilhoFundoMaxSR   = 0;
               setup.gatilhoFundoPrecoSR = 0;
               setup.gatilhoFundoPrecoSRdt  = 0;
            //--- critérios inversao de TOPO para FUNDO - SUPORTES
            //--- avaliar a possibilidade de inversao
            } else if(low[k-1] < setup.topo && 
               FuncaoReadDataBaseRSMaisProximo(db,"SUPORTE",low[k-1]) && 
               !setup.gatilhoFundoSR) {//já existe um TOPO definido
            //} else if(low[k-1] < setup.topo && FuncaoRSMaisProximo(low[k-1],arrayMinD1) && !setup.gatilhoFundoSR) {//já existe um TOPO definido
               //--- PROVÁVEL FUNDO
               setup.gatilhoTopoSR       = false; 
               setup.gatilhoTopoMinSR    = 0;               
               setup.gatilhoTopoPrecoSR  = 0;
               setup.gatilhoFundoSR      = true;        //--- Gatilho FUNDO que estava no estado "false", foi ativado para "true" - em razão de ser um provável FUNDO
               setup.gatilhoFundoMaxSR   = high[k-1];     //--- Máxima do Provável novo FUNDO - que deverá ser rompida pelo fechamento do candle posterior 
               setup.gatilhoFundoPrecoSR = low[k-1];      //--- Provável novo FUNDO
               setup.gatilhoFundoPrecoSRdt = time[k-1];
            //--- confirmacao da inversao
            } else if(low[k-1] < setup.topo && close[k-1]>setup.gatilhoFundoMaxSR + InputMargemGatilhoSR  && setup.gatilhoFundoSR) {//--- InputMargemSUPORTEeRESISTENCIA
               //--- CONFIRMAçãO DE NOVO FUNDO
               setup.fundo = setup.gatilhoFundoPrecoSR; //--- Atualização do Array de FUNDO
               //--- Atualização do Array de FUNDO
               InsertTable(db,"FUNDOS",setup.fundo,setup.gatilhoFundoPrecoSRdt,ulong(setup.gatilhoFundoPrecoSRdt));
               //---                setup.topo = -1;                         //--- TOPO passa a ser negativo, em razão de ter confirmação de FUNDO
               //---
               setup.gatilhoTopoSR       = false;
               setup.gatilhoTopoMinSR    = 0;               
               setup.gatilhoTopoPrecoSR  = 0;
               setup.gatilhoTopoPrecoSRdt = 0;
               setup.gatilhoTopoPrecoSRdt = 0;
               setup.gatilhoFundoSR      = false;
               setup.gatilhoFundoMaxSR   = 0;
               setup.gatilhoFundoPrecoSR = 0;
               setup.gatilhoFundoPrecoSRdt = 0;
               setup.gatilhoFundoPrecoSRdt = 0;
               //---
            }
         }//--- END else if (setup.fundo??0 && setup.topo??0)
      }//--- END if(InpUseFilterSUPORTEeRESISTENCIA) {
      if(InpUseFilterLT) {//PRICE, UDT
         //--- LTA - último fundo vigente como ponto inicial da LTA
         //--- SELECT PRICE,UDT FROM FUNDOS ORDER BY UDT DESC;
         //--- segundo ponto, é a mínima do Drawback imediatamente posterior ao último fundo vigente
         //--- SELECT PRICE FROM DRAWBACK ORDER BY UDT ASC
         //--- WHERE udtRef > UDT
         //---
      }
   //---
   //---   
   }
   return true;
//---
}
//+------------------------------------------------------------------+
//| CRIAR SÍMBOLO VISUAL - ARROW UP                                  |
//+------------------------------------------------------------------+
bool ArrowCreate(const long              chart_ID   = 0,                  // ID do gráfico
                 const string            name       = "Arrow",            // nome do sinal
                 const int               sub_window = 0,                  // índice da sub-janela
                 datetime                time       = 0,                  // ponto de ancoragem do tempo
                 double                  price      = 0,                  // ponto de ancoragem do preço
                 const ENUM_ARROW_ANCHOR anchor     = ANCHOR_BOTTOM,      // tipo de ancoragem
                 const ENUM_OBJECT       obj        = OBJ_ARROW_THUMB_UP, // tipo de objetto
                 const color             clr        = clrRed,             // cor do sinal
                 const ENUM_LINE_STYLE   style      = STYLE_SOLID,        // estilo de linha da borda
                 const int               width      = 1,                  // tamanho do sinal
                 const bool              back       = false,              // no fundo
                 const bool              selection  = true,               // destaque para mover
                 const bool              hidden     = true,               // ocultar na lista de objetos
                 const long              z_order    = 0) {                // prioridade para clicar no mouse
//--- redefine o valor de erro
   ResetLastError();
//--- criar o sinal
   if(!ObjectCreate(chart_ID, name, obj, sub_window, time, price)) {
      msg = StringFormat(__FUNCTION__,
                         ": falha ao criar o sinal \"Arrow\"! Código de erro = ", 
                         GetLastError());
      FuncaoPrint(msg);
      //---
      return(false);
   }
//--- tipo de definição de ancoragem
   ObjectSetInteger(chart_ID, name, OBJPROP_ANCHOR, anchor, (long)setup.lowFirstBar);
//--- definir uma cor de sinal
   ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr);
//--- definir o estilo da linha da borda
   ObjectSetInteger(chart_ID, name, OBJPROP_STYLE, style);
//--- tamanho da definição do sinal
   ObjectSetInteger(chart_ID, name, OBJPROP_WIDTH, width);
//--- exibir em primeiro plano (false) ou fundo (true)
   ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back);
//--- permitir (true) ou desabilitar (false) o modo de movimento do sinal com o mouse
//--- ao criar um objeto gráfico usando a função ObjectCreate, o objeto não pode ser
//--- destacado e movimentado por padrão. Dentro deste método, o parâmetro de seleção
//--- é verdade por padrão, tornando possível destacar e mover o objeto
   ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection);
   ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection);
//--- ocultar (true) ou exibir (false) o nome do objeto gráfico na lista de objeto
   ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden);
//--- definir a prioridade para receber o evento com um clique do mouse no gráfico
   ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order);
//--- sucesso na execução
   return(true);
} 
//+------------------------------------------------------------------+ 
//| LINHA HORIZONTAL                                                 | 
//+------------------------------------------------------------------+ 
bool HLineCreate(const long            chart_ID   = 0,           // ID DO GRÁFICO 
                 const string          name       = "HLine",     // Nome da linha 
                 const int             sub_window = 0,           // Subjanela index 
                 double                price      = 0,           // preço da linha
                 const color           clr        = clrRed,      // cor da linha
                 const ENUM_LINE_STYLE style      = STYLE_SOLID, // estilo da linha 
                 const int             width      = 1,           // largura da linha
                 const bool            back       = false,       // fundo 
                 const bool            selection  = true,        // realçar movimento 
                 const bool            hidden     = false,       // esconder na lista de objetos 
                 const long            z_order    = 0)           // prioridade para clique do mouse
  { 
//--- se o preço não está definido, defina-o no atual nível de preço Bid 
   if(!price) 
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID); 
//--- redefine o valor de erro 
   ResetLastError(); 
//--- criar um linha horizontal 
   if(!ObjectCreate(chart_ID,name,OBJ_HLINE,sub_window,0,price)) 
     { 
      msg = StringFormat(__FUNCTION__, 
                         ": falha ao criar um linha horizontal! Código de erro = ",
                         GetLastError());
      FuncaoPrint(msg);
      //--- 
      return(false); 
     } 
//--- definir cor da linha 
   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr); 
//--- definir o estilo de exibição da linha 
   ObjectSetInteger(chart_ID,name,OBJPROP_STYLE,style); 
//--- definir a largura da linha 
   ObjectSetInteger(chart_ID,name,OBJPROP_WIDTH,width); 
//--- exibir em primeiro plano (false) ou fundo (true) 
   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back); 
//--- habilitar (true) ou desabilitar (false) o modo do movimento da seta com o mouse 
//--- ao criar um objeto gráfico usando a função ObjectCreate, o objeto não pode ser 
//--- destacado e movimentado por padrão. Dentro deste método, o parâmetro de seleção 
//--- é verdade por padrão, tornando possível destacar e mover o objeto 
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection); 
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection); 
//--- ocultar (true) ou exibir (false) o nome do objeto gráfico na lista de objeto  
   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden); 
//--- definir a prioridade para receber o evento com um clique do mouse no gráfico 
   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order); 
//--- sucesso na execução 
   return(true); 
  } 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CreateDataBase() {
   //---
   string filename = "setup_ind_bruno.sqlite"; 
//--- criamos ou abrimos um banco de dados na pasta compartilhada do terminal 
   db = DatabaseOpen(filename, DATABASE_OPEN_READWRITE | DATABASE_OPEN_CREATE |DATABASE_OPEN_COMMON); 
   if(db == INVALID_HANDLE) 
     { 
      msg = StringFormat("DB: ", filename, " open failed with code ", GetLastError()); 
      FuncaoPrint(msg);
      //---
      return; 
     }
//--- criamos a tabela SUPORTE 
   if(!CreateTable(db,"SUPORTE")) 
     { 
      DatabaseClose(db); 
      return; 
     }   
//--- criamos a tabela RESISTENCIA 
   if(!CreateTable(db,"RESISTENCIA")) 
     { 
      DatabaseClose(db); 
      return; 
     }
//--- criamos a tabela PULLBACK 
   if(!CreateTable(db,"PULLBACK")) 
     { 
      DatabaseClose(db); 
      return; 
     }   
//--- criamos a tabela DRAWBACK 
   if(!CreateTable(db,"DRAWBACK")) 
     { 
      DatabaseClose(db); 
      return; 
     }        
//--- criamos a tabela PULLBACK2 (SECUNDÁRIO)
   if(!CreateTable(db,"PULLBACK2")) 
     { 
      DatabaseClose(db); 
      return; 
     }   
//--- criamos a tabela DRAWBACK2 (SECUNDÁRIO) 
   if(!CreateTable(db,"DRAWBACK2")) 
     { 
      DatabaseClose(db); 
      return; 
     }
//--- criamos a tabela LTA (LINHA DE TENDÊNCIA DE ALTA)
   if(!CreateTable(db,"LTA")) 
     { 
      DatabaseClose(db); 
      return; 
     }   
//--- criamos a tabela LTB (LINHA DE TENDÊNCIA DE BAIXA) 
   if(!CreateTable(db,"LTB")) 
     { 
      DatabaseClose(db); 
      return; 
     } 
//--- criamos a tabela TOPOS 
   if(!CreateTable(db,"TOPOS")) 
     { 
      DatabaseClose(db); 
      return; 
     }   
//--- criamos a tabela FUNDOS  
   if(!CreateTable(db,"FUNDOS")) 
     { 
      DatabaseClose(db); 
      return; 
     }                                    
}//END CreateDataBase
//+------------------------------------------------------------------+ 
//| Deletes a table with the specified name from the database        | 
//+------------------------------------------------------------------+ 
bool DeleteTable(int database, string table_name) { 
   string query = StringFormat("DROP TABLE %s", table_name);
   ResetLastError();
   if(!DatabaseExecute(database,query)) { 
      msg = StringFormat("Failed to drop table %s with code %d;",table_name,GetLastError()); 
      FuncaoPrint(msg);
      //---
      return(false); 
     } 
//--- the table has been successfully deleted 
   return(true); 
  } 
//+------------------------------------------------------------------+ 
//|   Cria a tabela database                                         | 
//+------------------------------------------------------------------+ 
bool CreateTable(const int database, const string table_name) { 
   //--- se a tabela XXXX existir, vamos exclui-la 
   string query = "";
   //---
   if(DatabaseTableExists(database, table_name)) { 
      //--- excluímos a tabela 
      query = StringFormat("DROP TABLE %s",table_name);
      if(!DatabaseExecute(database,query)) { 
         //---
         msg = StringFormat("Failed to drop table %s  with code %d ",table_name,GetLastError()); 
         FuncaoPrint(msg);
         //---
         return(false); 
      }
   } 
   //--- criamos a tabela  XXXX
   query = StringFormat("CREATE TABLE %s (" 
                        "UDT     INT PRIMARY KEY   NOT NULL," 
                        "PRICE   REAL              NOT NULL);",table_name);
   if(!DatabaseExecute(database,query)) { 
      //---
      msg = StringFormat("DB: create table %s failed with code %d ",table_name,GetLastError());
      FuncaoPrint(msg);
      //--- 
      return(false); 
   } 
   //--- sucesso 
   return(true); 
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool InsertTable(const int database, const string table_name, const double value, const datetime dt, const ulong udt) {
   //---
   string query = StringFormat("INSERT INTO %s (UDT,PRICE) VALUES (%d,%5f);",table_name,udt,value);
   //---
   if(!DatabaseExecute(database, query)) { 
      //---
      msg = StringFormat("%s insert failed with code %d",table_name,GetLastError()); 
      FuncaoPrint(msg);
      //--- 
      return(false); 
   }
   //---
   return true;
   //---
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FuncaoReadDatabase(int database, const string table_name) {
   //---
   int ret = -2;
   //--- prepare the request 
   string request_text=StringFormat("SELECT MAX(UDT), PRICE FROM %s;",table_name);
   int request=DatabasePrepare(database, request_text); 
   if(request==INVALID_HANDLE) 
     { 
      Print("DB: ", database, " request failed with code ", GetLastError()); 
      DatabaseClose(database); 
      return -3; 
     } 
   while(DatabaseRead(request)) 
     { 
      DatabaseColumnInteger(request, 1, ret); 
     } 
   //---
   printf("ret: %.2f",ret);     
   //--- delete request after use 
   DatabaseFinalize(request); 
   //--- close database 
   return ret;
}  
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool FuncaoReadDataBaseRSMaisProximo(int database, const string table_name, double price) {
   //--- prepare the request 
   string request_text=StringFormat("SELECT PRICE FROM %s ORDER BY PRICE DESC;",table_name);
   int request=DatabasePrepare(database, request_text); 
   double res;   
   if(request==INVALID_HANDLE) 
     { 
      Print("DB: ", database, " request failed with code ", GetLastError()); 
      DatabaseClose(database); 
      return false; 
     } 
   while(DatabaseRead(request)) { 
      //---
      DatabaseColumnDouble(request, 0, res);
      //---
      double dis = MathAbs(price - res);
      if(dis <= InputMargemSUPORTEeRESISTENCIA) {
         //---
         msg = StringFormat("%s -  Resistência e/ou Suporte Mais Próximo: Preço atual = %.2f; price = %.2f;",
                            __FUNCTION__,price,res,dis);
         FuncaoPrint(msg);
         //--- delete request after use 
         DatabaseFinalize(request); 
         //---
         return true;
         //---         
      }
      //---
     } 

   //--- delete request after use 
   DatabaseFinalize(request); 
   //--- close database 
   return false;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool FuncaoReadDataBaseLT2(int database, ulong udtRef,const string table_name, double priceRef) {
   //--- prepare the request 
   string request_text=StringFormat("SELECT PRICE FROM %s ORDER BY UDT ASC;",table_name);
   int request=DatabasePrepare(database, request_text); 
   double price = 0;
   ulong udt = 0;   
   //---
   if(request==INVALID_HANDLE) 
     { 
      Print("DB: ", database, " request failed with code ", GetLastError()); 
      DatabaseClose(database); 
      return false; 
     } 
   while(DatabaseRead(request)) { 
      //---
      
      DatabaseColumnDouble(request, 0, price);
      DatabaseColumnLong(request, 1, udt);
      //---
      if(udt>udtRef) {
         //---
         break;
         //---
      }
      //---
     } 

   //--- delete request after use 
   DatabaseFinalize(request); 
   if(price>0 && udt>0){
      //---
      //criar uma variavel/struct global memoria e atualizar com o price
      //criar uma variavel/struct global memoria e atualizar com o time
      //---
      return true;
      
   }
   //--- close database 
   return false;
} 
//+------------------------------------------------------------------+
//|                          Funcao Print                            |
//+------------------------------------------------------------------+
void FuncaoPrint(string txt) {
//---
   if(inpHabMsg)
      Print(txt);
//---
}
//---