//+------------------------------------------------------------------+
//|                                                          Fvg.mqh |
//|                                             Copyright 2025, Leo. |
//|                     https://www.mql5.com/es/users/nique_372/news |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Leo."
#property link      "https://www.mql5.com/es/users/nique_372/news"
#property strict

#ifndef ICTLIBRARY_CONCEPTS_BLOQUES_IMBALANCE_FVG_MQH
#define ICTLIBRARY_CONCEPTS_BLOQUES_IMBALANCE_FVG_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "..\\Base.mqh"

//+------------------------------------------------------------------+
//| Clase Wrapper CFvgBar                                            |
//+------------------------------------------------------------------+
class CFvgBar : public IImbalanceBlocks
 {
private:
  int                m_handle;
  //---
  void               Destroy();

public:
                     CFvgBar();
                    ~CFvgBar();

  //--- Creación
  bool               Create(string symbol, ENUM_TIMEFRAMES timeframe, long chart_id = 0, int subwin = 0, bool show_concept = true) override final;

  //--- Configuración específica
  inline void        Set(int range_, ENUM_MODO_OBTENCION_IMBALANCE mode_obtencin, ENUM_STYLE_DIBUJO_IMBALANCES style_draw_imbalacnes, TSN::CDiff* diff) override final;
  inline void        DesactivarUsoMarketBook() override final;

  //--- Configuración heredada
  inline void        SetGrapich(color clr_bull, color clr_bear, color clr_mitad_bull, color clr_mitad_bear, ENUM_LINE_STYLE style_concept,
                                bool fill_concept, int width_c, bool mostrar_mitad_, int max_espera, int width_line,
                                ENUM_LINE_STYLE style_mitad) override final;
  inline void        SetAlertas(bool activar, string alert_types) override final;
  inline void        SetCalculatePrevInNextBar() override final;

  //--- Gestión gráfica
  inline bool        ShowAll() override final;
  inline bool        HideAll() override final;
  inline bool        DeleteAll() override final;
  inline void        SetFlagMostrarObjetos(bool mostrar) override final;
  inline void        ForzeToActulizeCurrentTick() override final;

  //--- Eventos
  inline void        OnNewBar() override final;
  inline bool        IsNewBarConcept() override final;

  //--- Log
  inline void        AddLogFlags(const uint8_t flags) override final;
  void               RemoveLogFlags(const uint8_t flags) override final;

  //--- Obtención de datos - Mitigados
  inline void        GetAlcistasMitigados(Bloques &bloques[]) override final;
  inline void        GetBajistasMitigados(Bloques &bloques[]) override final;
  inline Bloques     GetAlcistaMitigado(const int pos) override final;
  inline Bloques     GetBajistaMitigiado(const int pos) override final;
  inline int         SizeAlcistasMitigados() override final;
  inline int         SizeBajistasMitigados() override final;

  //--- Obtención de datos - Activos
  inline Bloques     GetAlcista(const int index) override final;
  inline Bloques     GetBajista(const int index) override final;
  inline void        GetData(Bloques &alcistas[], Bloques &bajistas[]) override final;
  inline int         SizeAlcistas() override final;
  inline int         SizeBajistas() override final;

  //--- Obtención de datos - Extra
  inline Bloques     GetLastAlcista() override final;
  inline Bloques     GetLastBajista() override final;
  inline Bloques     GetMasCercanoAlcista() override final;
  inline Bloques     GetMasCercanoBajista() override final;

  //--- Control
  inline void        SetParo() override final;
  inline void        ChangeTimeframe(ENUM_TIMEFRAMES new_timeframe) override final;

  //--- Getters básicos
  inline int         Handle() const override final;
  inline string      Symbol() const override final;
  inline ENUM_TIMEFRAMES Timeframe() const override final;
  inline long        ChartId() const override final;
  inline int         Subwin() const override final;
  inline bool        InitialStateObj() const override final;
  inline ENUM_CONCEPT_UN_BLOQUE_TYPE BloqueType() const override final;

  inline uint8_t     ModifyFlags() const override final { return ICTFvg_ModifyFlags(m_handle); }
  inline bool        GetStateObj() const override final  { return ICTFvg_GetStateObj(m_handle); }
  inline void        Summary() const override final  {  ICTFvg_Summary(m_handle); }
  inline void        ChangeChart(long new_chart_id, int new_subwin) override final  {  ICTFvg_ChangeChart(m_handle, new_chart_id, new_subwin); }

 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CFvgBar::CFvgBar() : m_handle(INVALID_HANDLE)
 {

 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CFvgBar::~CFvgBar()
 {
  Destroy();
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CFvgBar::Create(string symbol, ENUM_TIMEFRAMES timeframe, long chart_id = 0, int subwin = 0, bool show_concept = true)
 {
  if(m_handle != INVALID_HANDLE)
    Destroy();

  m_handle = ICTFvg_Create(symbol, timeframe, chart_id, subwin, show_concept);

  if(m_handle < 0)
   {
    LogError("No se pudo crear un handle para CFvgBar", FUNCION_ACTUAL);
    Remover();
    return false;
   }

  return true;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::Set(int range_, ENUM_MODO_OBTENCION_IMBALANCE mode_obtencin, ENUM_STYLE_DIBUJO_IMBALANCES style_draw_imbalacnes, TSN::CDiff* diff)
 {
  ICTFvg_Set(m_handle, range_, mode_obtencin, style_draw_imbalacnes, diff);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::SetGrapich(color clr_bull, color clr_bear, color clr_mitad_bull, color clr_mitad_bear, ENUM_LINE_STYLE style_concept,
                                bool fill_concept, int width_c, bool mostrar_mitad_, int max_espera, int width_line, ENUM_LINE_STYLE style_mitad)
 {
  ICTFvg_SetGrapich(m_handle, clr_bull, clr_bear, clr_mitad_bull, clr_mitad_bear, style_concept, fill_concept, width_c, mostrar_mitad_, max_espera, width_line, style_mitad);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgBar::ShowAll()
 {
  return ICTFvg_ShowAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgBar::HideAll()
 {
  return ICTFvg_HideAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgBar::DeleteAll()
 {
  return ICTFvg_DeleteAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::SetAlertas(bool activar, string alert_types)
 {
  ICTFvg_SetAlertas(m_handle, activar, alert_types);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::SetFlagMostrarObjetos(bool mostrar)
 {
  ICTFvg_SetFlagMostrarObjetos(m_handle, mostrar);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::ForzeToActulizeCurrentTick()
 {
  ICTFvg_ForzeToActulizeCurrentTick(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::OnNewBar()
 {
  ICTFvg_OnNewBar(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgBar::IsNewBarConcept()
 {
  return ICTFvg_IsNewBarConcept(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::SetCalculatePrevInNextBar()
 {
  ICTFvg_SetCalculatePrevInNextBar(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::AddLogFlags(const uint8_t flags)
 {
  CLoggerBase::AddLogFlags(flags);
  ICTFvg_AddLogFlag(m_handle, flags);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CFvgBar::RemoveLogFlags(const uint8_t flags)
 {
  CLoggerBase::RemoveLogFlags(flags);
  ICTFvg_RemoverLogFlags(m_handle, flags);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::GetAlcistasMitigados(Bloques &bloques[])
 {
  ICTFvg_GetAlcistasMitigados(m_handle, bloques);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::GetBajistasMitigados(Bloques &bloques[])
 {
  ICTFvg_GetBajistasMitigados(m_handle, bloques);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetAlcistaMitigado(const int pos)
 {
  return ICTFvg_GetAlcistaMitigado(m_handle, pos);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetBajistaMitigiado(const int pos)
 {
  return ICTFvg_GetBajistaMitigado(m_handle, pos);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::SizeAlcistasMitigados()
 {
  return ICTFvg_SizeAlcistasMitigados(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::SizeBajistasMitigados()
 {
  return ICTFvg_SizeBajistasMitigados(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetAlcista(const int index)
 {
  return ICTFvg_GetAlcista(m_handle, index);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetBajista(const int index)
 {
  return ICTFvg_GetBajista(m_handle, index);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::GetData(Bloques &alcistas[], Bloques &bajistas[])
 {
  ICTFvg_GetData(m_handle, alcistas, bajistas);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::SizeAlcistas()
 {
  return ICTFvg_SizeAlcistas(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::SizeBajistas()
 {
  return ICTFvg_SizeBajistas(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetLastAlcista()
 {
  return ICTFvg_GetLastAlcista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetLastBajista()
 {
  return ICTFvg_GetLastBajista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetMasCercanoAlcista()
 {
  return ICTFvg_GetMasCercanoAlcista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgBar::GetMasCercanoBajista()
 {
  return ICTFvg_GetMasCercanoBajista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::SetParo()
 {
  ICTFvg_SetParo(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::ChangeTimeframe(ENUM_TIMEFRAMES new_timeframe)
 {
  ICTFvg_ChangeTimeframe(m_handle, new_timeframe);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgBar::DesactivarUsoMarketBook()
 {
  ICTFvg_DesactivarUsoMarketBook(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::Handle() const
 {
  return m_handle;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline string CFvgBar::Symbol() const
 {
  return ICTFvg_Simbolo(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline ENUM_TIMEFRAMES CFvgBar::Timeframe() const
 {
  return ICTFvg_Timeframe(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline long CFvgBar::ChartId() const
 {
  return ICTFvg_ChartId(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgBar::Subwin() const
 {
  return ICTFvg_Subwin(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgBar::InitialStateObj() const
 {
  return ICTFvg_GetInittialStateObj(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline ENUM_CONCEPT_UN_BLOQUE_TYPE CFvgBar::BloqueType() const
 {
  return ICTFvg_BloqueType(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CFvgBar::Destroy()
 {
  if(m_handle != INVALID_HANDLE)
   {
    ICTFvg_Delete(m_handle);
    m_handle = INVALID_HANDLE;
   }
 }



//+------------------------------------------------------------------+
//| Clase Wrapper CFvgTick                                           |
//+------------------------------------------------------------------+
class CFvgTick : public IBlockTick<IImbalanceBlocks>
 {
private:
  int                m_handle;
  //---
  void               Destroy();

public:
                     CFvgTick();
                    ~CFvgTick();

  //--- Creación
  bool               Create(string symbol, ENUM_TIMEFRAMES timeframe, long chart_id = 0, int subwin = 0, bool show_concept = true) override final;

  //--- Configuración específica
  inline void        Set(int range_, ENUM_MODO_OBTENCION_IMBALANCE mode_obtencin, ENUM_STYLE_DIBUJO_IMBALANCES style_draw_imbalacnes, TSN::CDiff* diff) override final;
  inline void        DesactivarUsoMarketBook() override final;

  //--- Configuración heredada
  inline void        SetGrapich(color clr_bull, color clr_bear, color clr_mitad_bull, color clr_mitad_bear, ENUM_LINE_STYLE style_concept,
                                bool fill_concept, int width_c, bool mostrar_mitad_, int max_espera, int width_line,
                                ENUM_LINE_STYLE style_mitad) override final;
  inline void        SetAlertas(bool activar, string alert_types) override final;
  inline void        SetCalculatePrevInNextBar() override final;

  //--- Gestión gráfica
  inline bool        ShowAll() override final;
  inline bool        HideAll() override final;
  inline bool        DeleteAll() override final;
  inline void        SetFlagMostrarObjetos(bool mostrar) override final;
  inline void        ForzeToActulizeCurrentTick() override final;
  inline bool        IsNewBarConcept() override final;

  //--- Eventos
  inline void        OnNewBar() override final;

  inline void        OnTickEvent(datetime curr_time) override final;
  inline void        FreeArrayMitigated() override final;

  //--- Log
  inline void        AddLogFlags(const uint8_t flags) override final;
  void               RemoveLogFlags(const uint8_t flags) override final;

  //--- Obtención de datos - Mitigados
  inline void        GetAlcistasMitigados(Bloques &bloques[]) override final;
  inline void        GetBajistasMitigados(Bloques &bloques[]) override final;
  inline Bloques     GetAlcistaMitigado(const int pos) override final;
  inline Bloques     GetBajistaMitigiado(const int pos) override final;
  inline int         SizeAlcistasMitigados() override final;
  inline int         SizeBajistasMitigados() override final;

  //--- Obtención de datos - Activos
  inline Bloques     GetAlcista(const int index) override final;
  inline Bloques     GetBajista(const int index) override final;
  inline void        GetData(Bloques &alcistas[], Bloques &bajistas[]) override final;
  inline int         SizeAlcistas() override final;
  inline int         SizeBajistas() override final;

  //--- Obtención de datos - Extra
  inline Bloques     GetLastAlcista() override final;
  inline Bloques     GetLastBajista() override final;
  inline Bloques     GetMasCercanoAlcista() override final;
  inline Bloques     GetMasCercanoBajista() override final;

  //--- Control
  inline void        SetParo() override final;
  inline void        ChangeTimeframe(ENUM_TIMEFRAMES new_timeframe) override final;

  //--- Getters básicos
  inline int         Handle() const override final;
  inline string      Symbol() const override final;
  inline ENUM_TIMEFRAMES Timeframe() const override final;
  inline long        ChartId() const override final;
  inline int         Subwin() const override final;
  inline bool        InitialStateObj() const override final;
  inline ENUM_CONCEPT_UN_BLOQUE_TYPE BloqueType() const override final;

  inline uint8_t     ModifyFlags() const override final { return ICTFvgTick_ModifyFlags(m_handle); }
  inline bool        GetStateObj() const override final  { return ICTFvgTick_GetStateObj(m_handle); }
  inline void        Summary() const override final  {  ICTFvgTick_Summary(m_handle); }
  inline void        ChangeChart(long new_chart_id, int new_subwin) override final  {  ICTFvgTick_ChangeChart(m_handle, new_chart_id, new_subwin); }

 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CFvgTick::CFvgTick() : m_handle(INVALID_HANDLE)
 {

 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CFvgTick::~CFvgTick()
 {
  Destroy();
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CFvgTick::Create(string symbol, ENUM_TIMEFRAMES timeframe, long chart_id = 0, int subwin = 0, bool show_concept = true)
 {
  if(m_handle != INVALID_HANDLE)
    Destroy();

  m_handle = ICTFvgTick_Create(symbol, timeframe, chart_id, subwin, show_concept);

  if(m_handle < 0)
   {
    LogError("No se pudo crear un handle para CFvgTick", FUNCION_ACTUAL);
    Remover();
    return false;
   }

  return true;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::Set(int range_, ENUM_MODO_OBTENCION_IMBALANCE mode_obtencin, ENUM_STYLE_DIBUJO_IMBALANCES style_draw_imbalacnes, TSN::CDiff* diff)
 {
  ICTFvgTick_Set(m_handle, range_, mode_obtencin, style_draw_imbalacnes, diff);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::SetGrapich(color clr_bull, color clr_bear, color clr_mitad_bull, color clr_mitad_bear, ENUM_LINE_STYLE style_concept,
                                 bool fill_concept, int width_c, bool mostrar_mitad_, int max_espera, int width_line, ENUM_LINE_STYLE style_mitad)
 {
  ICTFvgTick_SetGrapich(m_handle, clr_bull, clr_bear, clr_mitad_bull, clr_mitad_bear, style_concept, fill_concept, width_c, mostrar_mitad_, max_espera, width_line, style_mitad);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgTick::ShowAll()
 {
  return ICTFvgTick_ShowAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgTick::HideAll()
 {
  return ICTFvgTick_HideAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgTick::DeleteAll()
 {
  return ICTFvgTick_DeleteAll(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::SetAlertas(bool activar, string alert_types)
 {
  ICTFvgTick_SetAlertas(m_handle, activar, alert_types);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::SetFlagMostrarObjetos(bool mostrar)
 {
  ICTFvgTick_SetFlagMostrarObjetos(m_handle, mostrar);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::ForzeToActulizeCurrentTick()
 {
  ICTFvgTick_ForzeToActulizeCurrentTick(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::OnNewBar()
 {
  ICTFvgTick_OnNewBar(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgTick::IsNewBarConcept()
 {
  return ICTFvgTick_IsNewBarConcept(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::SetCalculatePrevInNextBar()
 {
  ICTFvgTick_SetCalculatePrevInNextBar(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::OnTickEvent(datetime curr_time)
 {
  ICTFvgTick_OnTickEvent(m_handle, curr_time);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::FreeArrayMitigated()
 {
  ICTFvgTick_FreeArrayMitigated(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::AddLogFlags(const uint8_t flags)
 {
  CLoggerBase::AddLogFlags(flags);
  ICTFvgTick_AddLogFlag(m_handle, flags);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CFvgTick::RemoveLogFlags(const uint8_t flags)
 {
  CLoggerBase::RemoveLogFlags(flags);
  ICTFvgTick_RemoverLogFlags(m_handle, flags);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::GetAlcistasMitigados(Bloques &bloques[])
 {
  ICTFvgTick_GetAlcistasMitigados(m_handle, bloques);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::GetBajistasMitigados(Bloques &bloques[])
 {
  ICTFvgTick_GetBajistasMitigados(m_handle, bloques);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetAlcistaMitigado(const int pos)
 {
  return ICTFvgTick_GetAlcistaMitigado(m_handle, pos);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetBajistaMitigiado(const int pos)
 {
  return ICTFvgTick_GetBajistaMitigado(m_handle, pos);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::SizeAlcistasMitigados()
 {
  return ICTFvgTick_SizeAlcistasMitigados(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::SizeBajistasMitigados()
 {
  return ICTFvgTick_SizeBajistasMitigados(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetAlcista(const int index)
 {
  return ICTFvgTick_GetAlcista(m_handle, index);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetBajista(const int index)
 {
  return ICTFvgTick_GetBajista(m_handle, index);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::GetData(Bloques &alcistas[], Bloques &bajistas[])
 {
  ICTFvgTick_GetData(m_handle, alcistas, bajistas);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::SizeAlcistas()
 {
  return ICTFvgTick_SizeAlcistas(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::SizeBajistas()
 {
  return ICTFvgTick_SizeBajistas(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetLastAlcista()
 {
  return ICTFvgTick_GetLastAlcista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetLastBajista()
 {
  return ICTFvgTick_GetLastBajista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetMasCercanoAlcista()
 {
  return ICTFvgTick_GetMasCercanoAlcista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline Bloques CFvgTick::GetMasCercanoBajista()
 {
  return ICTFvgTick_GetMasCercanoBajista(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::SetParo()
 {
  ICTFvgTick_SetParo(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::ChangeTimeframe(ENUM_TIMEFRAMES new_timeframe)
 {
  ICTFvgTick_ChangeTimeframe(m_handle, new_timeframe);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline void CFvgTick::DesactivarUsoMarketBook()
 {
  ICTFvgTick_DesactivarUsoMarketBook(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::Handle() const
 {
  return m_handle;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline string CFvgTick::Symbol() const
 {
  return ICTFvgTick_Simbolo(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline ENUM_TIMEFRAMES CFvgTick::Timeframe() const
 {
  return ICTFvgTick_Timeframe(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline long CFvgTick::ChartId() const
 {
  return ICTFvgTick_ChartId(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline int CFvgTick::Subwin() const
 {
  return ICTFvgTick_Subwin(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline bool CFvgTick::InitialStateObj() const
 {
  return ICTFvgTick_GetInittialStateObj(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
inline ENUM_CONCEPT_UN_BLOQUE_TYPE CFvgTick::BloqueType() const
 {
  return ICTFvgTick_BloqueType(m_handle);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CFvgTick::Destroy()
 {
  if(m_handle != INVALID_HANDLE)
   {
    ICTFvgTick_Delete(m_handle);
    m_handle = INVALID_HANDLE;
   }
 }


#endif // ICTLIBRARY_CONCEPTS_BLOQUES_IMBALANCE_FVG_MQH
//+------------------------------------------------------------------+