MQL5 RiferimentoCostanti, Enumerazioni e StruttureCostanti del GraficoEsempi di Lavoro con il grafico Chart

Esempi di Lavoro con il grafico Chart

Questa sezione contiene esempi di lavoro con le proprietà del chart. Uno o due funzioni complete vengono visualizzate per ogni proprietà. Queste funzioni permettono di impostare/ricevere il valore della proprietà. Queste funzioni possono essere utilizzate "così come sono" nelle applicazioni mql5 personalizzate.

La figura seguente mostra il pannello grafico che illustra come la modifica delle proprietà del chart cambia il suo aspetto. Il click sul pulsante Avanti permette di impostare il nuovo valore della proprietà appropriata e visualizzare le modifiche nella finestra del grafico.

chart_properties_panel

Il codice sorgente del pannello si trova sotto.

Proprietà del Chart e Funzioni di Esempio per lavorare con Esse

CHART_IS_OBJECTdefinisce se un oggetto è un chart reale o un oggetto grafico.

//+--------------------------------------------------------------------------------+
//| Controlla se un oggetto è un chart. Se è un oggetto grafico,                   |
//| il risultato è true. Se è un vero chart, la variable risultato                 |
//| ha il valore di false.                                                         |
//+--------------------------------------------------------------------------------+
bool ChartIsObject(bool &result,constlong chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
/ --- ottiene la proprietà chart
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      //--- restituisce false
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }

CHART_BRING_TO_TOP mostra il chart in cima a tutti gli altri.

//+-------------------------------------------------------------------------------+
//| Invia il comando al terminale per visualizzare il chart sopra tutti gli altri |
//+-------------------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- mostra il chart in cima a tutti gli altri
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_MOUSE_SCROLL è una proprietà di scorrimento del chart usando il tasto sinistro del mouse.

//+-----------------------------------------------------------------------------------------+
//| Controlla se lo scorrimento del chart usando il tasto sinistro del mouse è abilitato    |
//+-----------------------------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+----------------------------------------------------------------------------------+
//| Abilita/disabilita lo scorrimento del chart usando il bottone sinistro del mouse |
//+----------------------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_EVENT_MOUSE_MOVE è una proprietà di invio messaggi riguardanti eventi di movimento e click del mouse per applicazioni mql5 (CHARTEVENT_MOUSE_MOVE).

//+--------------------------------------------------------------------------------+
//| Controlla se i messaggi concernenti eventi di spostamento ed i click del mouse |
//| vengono inviati a tutte le applicazioni MQL5 sul chart                         |
//+--------------------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//-------------------------------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità invio messaggi concernente eventi di spostamento                      |
//| e di click del mouse alle applicazioni MQL5 sul chart                                                |
//-------------------------------------------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_EVENT_OBJECT_CREATE è una proprietà di invio messaggi riguardanti l'evento di creazione di un oggetto grafico in applicazioni mql5 (CHARTEVENT_OBJECT_CREATE).

//+-----------------------------------------------------------------------------------------+
//| Controlla se i messaggi riguardanti gli eventi di                                       |
//| creazione degli oggetti grafici vengono inviati a tutte le applicazioni mql5 sul chart  |
//+-----------------------------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+-----------------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità di invio messaggi riguardanti gli eventi di              |
//| creazione di un oggetto grafico su tutte le applicazioni mql5 sul chart                 |
//+-----------------------------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_EVENT_OBJECT_DELETE è una proprietà di trasmissione dei messaggi concernente l'evento di delezione(eliminazione) di un oggetto grafico in applicazioni mql5 (CHARTEVENT_OBJECT_DELETE).

//+-----------------------------------------------------------------------------------------+
//| Controlla se i messaggi concernenti l'evento dell'eliminazione                          |
//| di oggetti grafici, viene inviato a tutte le applicazioni mql5 sul chart                |
//+-----------------------------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,constlong chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+-----------------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità di invio messaggi riguardanti gli eventi di |
//| eliminazione di oggetti grafici a tutte le applicazioni mql5 sul chart |
//+-----------------------------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_MODE – tipo di chart (candele, barre o linea).

//+--------------------------------------------------------------------------------+
//| Ottiene il tipo di display del chart (candele, barre o linea)             |
//+--------------------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=WRONG_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((ENUM_CHART_MODE)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il tipo di display del chart (candele, barre o linea)             |
//+--------------------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_FOREGROUND è una proprietà di visualizzazione di un chart dei prezzi in primo piano.

//+--------------------------------------------------------------------------------+
//| Controlla se il chart dei prezzi è visualizzato in primo piano |
//+--------------------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione del chart dei prezzi in primo piano   |
//+--------------------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHIFT - modalità di spostamento del chart dei prezzi dal bordo destro.

//+-------------------------------------------------------------------------------------+
//| Controlla se lo slittamento del chart dei prezzi dal bordo destro è abilitata |
//+-------------------------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione del chart prezzi con uno shift dal bordo destro |
//+--------------------------------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_AUTOSCROLL - la modalità di slittamento automatico al bordo destro del chart.

//+--------------------------------------------------------------------------------+
//| Controlla se lo scorrimento automatico del chart sulla destra            |
//| sull'arrivo dei nuovi ticks è abilitata                                  |
//+--------------------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita lo scorrimento automatico del chart sulla destra     |
//| all'arrivo di nuovi ticks                                             |
//+--------------------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SCALE – proprietà di scala del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene la scala del chart (da 0 a 5)                                   |
//+--------------------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta la scala del chart (da 0 a 5)                                   |
//+--------------------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SCALEFIX – la modalità di scala fissa del chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la modalità scala fissa è abilitata                        |
//+--------------------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità scala fissa                            |
//+--------------------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SCALEFIX_11 – modalità 1:1 di scala del chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la scala "1:1" è abilitata                            |
//+--------------------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità scala "1:1"                            |
//+--------------------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SCALE_PT_PER_BAR – la modalità di specificazione della scala del chart, in punti per barra.

//+--------------------------------------------------------------------------------+
//| Controlla se la modalità di scala "punti per barra" è abilitata |
//+--------------------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la modalità di scala del chart "punti per barra" |
//+--------------------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_OHLC – la proprietà di visualizzazione di valori OHLC nell'angolo superiore sinistro.

//-------------------------------------------------------------------------------------------------------+
//| Controlla se la visualizzazione dei valori OHLC nell'angolo superiore sinistro del chart è abilitata |
//-------------------------------------------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//-------------------------------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione dei valori OHLC nell'angolo superiore sinistro del chart |
//-------------------------------------------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_BID_LINE – la proprietà di visualizzazione del valore Bid come linea orizzontale sul chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la visualizzazione della linea Bid sul chart è abilitata |
//+--------------------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della linea Bid sul chart                |
//+--------------------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_ASK_LINE – la proprietà di visualizzazione valori Ask come linea orizzontale su un chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la visualizzazione della linea Ask sul chart è abilitata |
//+--------------------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della linea Ask sul chart                |
//+--------------------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_LAST_LINE – la proprietà di visualizzazione valore Last come una linea orizzontale in un chart.

//+---------------------------------------------------------------------------------------+
//| Controlla se la visualizzazione della linea per l'ultimo prezzo eseguito, è abilitata |
//+---------------------------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+---------------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della linea per l'ultimo prezzo eseguito |
//+---------------------------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_PERIOD_SEP – la proprietà di visualizzazione dei separatori verticali tra periodi adiacenti.

//+--------------------------------------------------------------------------------------------+
//| Controlla se la visualizzazione dei separatori verticali tra periodi adiacenti è abilitata |
//+--------------------------------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+---------------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione dei separatori verticali tra periodi adiacenti |
//+---------------------------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_GRID – la proprietà di visualizzazione di della griglia del chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la griglia del chart è visualizzata                            |
//+--------------------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della griglia sul chart                  |
//+--------------------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_VOLUMES – la proprietà di visualizzazione dei volumi sul chart.

//+--------------------------------------------------------------------------------+
//| Controlla se i volumi vengono visualizzati sul chart (tre possibilità: |
//| non vengono visualizzati, volumi tick visualizzati, volumi reali visualizzati) |
//+--------------------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=WRONG_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta la modalità di visualizzazione dei volumi sul chart                    |
//+--------------------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_OBJECT_DESCR – la proprietà della descrizione pop-up dell'oggetto grafico.

//+-------------------------------------------------------------------------------------+
//| Controlla se le descrizioni descriptions degli oggetti grafici vengono visualizzate |
//| quando si tiene il mouse su esse                                     |
//+-------------------------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+---------------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione di descrizioni pop-up di oggetti grafici |
//| quando si tiene il mouse su esse                                     |
//+---------------------------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_VISIBLE_BARS definisce il numero di barre su un grafico che sono disponibili per la visualizzazione.

//+-------------------------------------------------------------------------------+
//| Ottiene il numero di barre che sono visualizzate (visibili) nel chart |
//+-------------------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_WINDOWS_TOTAL definisce il numero totale di finestre chart, tra cui le sottofinestre indicatori.

//+-------------------------------------------------------------------------------------+
//| Ottiene il numero totale di finestre del chart, tra cui indicatori sottofinestre |
//+-------------------------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_WINDOW_IS_VISIBLE definisce la visibilità della sottofinestra.

//+--------------------------------------------------------------------------------+
//| Verifica se la finestra del grafico corrente, o sottofinestra, è visibile |
//+--------------------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }

CHART_WINDOW_HANDLE restituisce l'handle del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene l'handle del chart                                            |
//+--------------------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_WINDOW_YDISTANCE definisce la distanza in pixel tra il frame superiore della sottofinestra indicatore ed il frame superiore della finestra principale del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene la distanza in pixel tra il bordo superiore di          |
//| Sottoffinestra e bordo superiore della finestra superiore del chart |
//+--------------------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_FIRST_VISIBLE_BAR restituisce il numero della prima barra visibile sul chart (indicizzazione barra corrisponde alle timeseries).

//-------------------------------------------------------------------------------------------------------+
//| Ottiene l'indice della prima barra visibile sul chart |                            |
//| L'indicizzazione avviene come in timeseries: le ultime barre hanno indice inferiore | //| |
//-------------------------------------------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_WIDTH_IN_BARS restituisce lo spessore del chart, in barre.

//+--------------------------------------------------------------------------------+
//| Ottiene lo spessore del chart (in barre)                                |
//+--------------------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_WIDTH_IN_PIXELS restituisce lo spessore del chart, in pixels.

//+--------------------------------------------------------------------------------+
//| Ottiene lo spessore del chart (in pixels)                            |
//+--------------------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }

CHART_HEIGHT_IN_PIXELS – proprietà altezza del chart, in pixels.

//+--------------------------------------------------------------------------------+
//| Ottiene l'altezza del chart (in pixels)                             |
//+--------------------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long result=-1;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((int)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta l'altezza del chart (in pixels)                             |
//+--------------------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_BACKGROUND - colore di sfondo del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore di sottofondo del chart                               |
//+--------------------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore di sfondo del chart
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore di sottofondo del chart                               |
//+--------------------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore di sfondo del chart
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_FOREGROUND - colore degli assi, la scala e la linea OHLC.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore degli assi, scala e linea OHLC                      |
//+--------------------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il colore degli assi, dekla scala e della linea OHLC
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore degli assi, scala e linea OHLC                  |
//+--------------------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore degli assi, della scala e della linea OHLC
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_GRID – colore della griglia del chart.

//+--------------------------------------------------------------------------------+
//| Imposta il colore della griglia del chart                                     |
//+--------------------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della griglia del chart
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore della griglia del chart                                     |
//+--------------------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della griglia del chart
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_VOLUME - colore di volumi e dei livelli di apertura posizione.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore dei livelli di entry dei volumi e del market |
//+--------------------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore dei volumi e dei livelli di ingresso nel mercato
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore dei livelli di entry dei volumi e del market |
//+--------------------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta i colori dei volumi e dei livelli di ingresso sul mercato
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_CHART_UP - colore della barra superiore, la sua ombra ed il bordo del corpo della candela rialzista.

//+---------------------------------------------------------------------------------------+
//| Ottiene il colore di barra superiore, ombra e bordo (corpo di candela bullish) |
//+---------------------------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della barra superiore, la sua ombra ed il bordo del corpo della candela rialzista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore di barra superiore, ombra e bordo (corpo di candela bullish) |
//+--------------------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della barra superiore, la sua ombra ed bordo del corpo di una candela rialzista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_CHART_DOWN - colore della barra inferiore, la sua ombra ed bordo del corpo della candela ribassista.

//+-------------------------------------------------------------------------------+
//| Ottiene il colore di barra inferiore, ombra e bordo (corpo di candela bullish) |
//+-------------------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della barra inferiore, la sua ombra ed il bordo del corpo della candela ribassista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+-------------------------------------------------------------------------------+
//| Imposta il colore di barra inferiore, ombra e bordo (corpo di candela bullish) |
//+-------------------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della barra inferiore, la sua ombra ed il bordo del corpo della candela ribassista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_CHART_LINE - colore della linea del chart e della candela Doji.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore della linea del chart e candele Doji |
//+--------------------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della linea del chart e della candela Doji
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore della linea del chart e candele Doji |
//+--------------------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta i colori della linea del grafico e delle candele Doji
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_CANDLE_BULL – colore del bordo della candela rialzista.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore del corpo della candela bullish |
//+--------------------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore del corpo della candela rialzista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore del corpo della candela bullish |
//+--------------------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore del corpo della candela rialzista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_CANDLE_BEAR – colore del corpo della candela ribassista.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore del corpo della candela bearish |
//+--------------------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore del corpo della candela ribassista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore del corpo della candela bearish |
//+--------------------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore del corpo della candela ribassista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_BID – colore della linea di prezzo Bid.

//+--------------------------------------------------------------------------------+
//| Imposta il colore della linea Bid                                     |
//+--------------------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della linea di prezzo Bid
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore della linea Bid                                       |
//+--------------------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della linea di prezzo Bid
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_ASK – colore della linea di prezzo Ask.

//+--------------------------------------------------------------------------------+
//| Ottiene il colore della linea Ask                                     |
//+--------------------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore della linea di prezzo Ask
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore della linea Ask                                       |
//+--------------------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della linea di prezzo Ask
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_LAST - colore della linea di prezzo dell'ultimo affare eseuito (Last).

//+--------------------------------------------------------------------------------+
//| Ottiene il colore della linea dell'ultimo affare eseguito |
//+--------------------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il colore della lina di prezzo dell'ultimo affare eseguito (Last)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore della linea dell'ultimo affare eseguito |
//+--------------------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore della lina di prezzo dell'ultimo affare eseguito (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_COLOR_STOP_LEVEL – colore dei livelli di stop order (Stop Loss e Take Profit).

//+--------------------------------------------------------------------------------+
//| Ottiene il colore dei livelli di Stop Loss e Take Profit               |
//+--------------------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- prepara la variabile a ricevere il colore
   long result=clrNONE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il colore dei livelli degli stop orders (Stop Loss e Take Profit)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return((color)result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il colore dei livelli di Stop Loss e Take Profit               |
//+--------------------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il colore dei livelli degli ordini di stop (Stop Loss e Take Profit)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_TRADE_LEVELS - proprietà di visualizzazione di livelli di trade sul chart (livelli di posizioni aperte, Stop Loss, Take Profit ed ordini in attesa).

//+--------------------------------------------------------------------------------+
//| Controlla se i livelli di trading vengono visualizzati sul chart |
//+--------------------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/Disabilita la visualizzazione dei livelli di trading |
//+--------------------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_DRAG_TRADE_LEVELS - di proprietà di abilitazione della possibilità di trascinare i livelli di trading su un chart usando il mouse.

//+-------------------------------------------------------------------------------+
//| Controlla se consente il trascinamento livelli di trading sul chart, col mouse |
//+-------------------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita il trascinamento dei livelli di trading sul chart col mouse |
//+--------------------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_DATE_SCALE - proprietà di visualizzazione della scala temporale su un chart.

//+--------------------------------------------------------------------------------+
//| Controlla se la scala temporale è visualizzata sul chart |
//+--------------------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della scala temporale sul chart |
//+--------------------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_PRICE_SCALE - di proprietà di visualizzazione della scala di prezzo su un chart.

//+--------------------------------------------------------------------------------+
//| ChControlla se la scala prezzo è visualizzata sul chart |
//+--------------------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
/ --- preparara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà chart in memoria
   result=value;
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione della scala prezzo sul chart |
//+--------------------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_SHOW_ONE_CLICK – property of displaying the "One click trading" panel on a chart.

//+------------------------------------------------------------------+
// | Controlla se il pannello "One click trading" viene visualizzato sul chart |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il valore della proprietà
   long value;
//--- resetta il valore dell' errore
   ResetLastError();
//--- riceve il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- mostra il messaggio d'errore nel journal dell'Expert
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà del chart nella memoria
   result=value;
//--- esecuzione con successo
   return(true);
  }
//+------------------------------------------------------------------+
//| Abilita/disabilita la visualizzazione del pannello "One click trading" |
//| sul chart                                                         |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- mostra il messaggio d'errore nel journal dell'Expert
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione con successo
   return(true);
  }

CHART_SHIFT_SIZE - grandezza di slittamento della barra zero dal bordo destro in valori percentuali.

//+-----------------------------------------------------------------+
//| Ottiene la grandezza dello slittamento della barra zero dal bordo sinistro |
//| del chart, in valori percentuali (dal 10% fino al 50%) |
//+-----------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }
//+---------------------------------------------------------------------------------------+
//| Ottiene la grandezza dello slittamento della barra zero dal bordo destro |
//| del grafico in valori percentuali (dal 10% fino al 50%).                     |
//| Per abilitare shift mode il valore della proprietà CHART_SHIFT dev'essere true| //| |
//+---------------------------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_FIXED_POSITION - la posizione fissata del chart dal bordo sinistro in valore percentuale.

//+----------------------------------------------------------------------------------------+
//| Ottiene il punto della posizione fissa del chart dal bordo sin. (in valori percent.)|
//+----------------------------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }
//+-----------------------------------------------------------------------------------------+
//| Ottiene il punto della posizione fissa del chart dal bordo sin. (in valori percent.) //| |
//| Per visualizzare il punto della posizione fissa del chart, il valore della proprietà |
//| CHART_AUTOSCROLL dev'essere impostato come false  |                                                                 |
//+-----------------------------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_FIXED_MAX – proprietà del massimo fissato del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene il valore del massimo fissato del chart |
//+--------------------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il valore del massimo fissato del chart |                         |
//| Per cambiare il valore della proprietà, il valore della proprietà |
//| dev'essere preliminarmente impostato come true | |
//+--------------------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_FIXED_MIN – proprietà del minimo fissato del chart.

//+--------------------------------------------------------------------------------+
//| Ottiene il valore del minimo fissato del chart |
//+--------------------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }
//+--------------------------------------------------------------------------------+
//| Imposta il valore del minimo fissato del chart |                         |
//| Per cambiare il valore della proprietà, il valore della proprietà |
//| dev'essere preliminarmente impostato come true | |
//+--------------------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_POINTS_PER_BAR – valore della scala in punti per barra.

//+--------------------------------------------------------------------------------+
//| Ottiene il valore della scala del chart in punti per barra |
//+--------------------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }
//+-------------------------------------------------------------------------------+
//| Imposta il valore della scala del chart in punti per barra |                     |
//| Per vedere il risultato di questo cambio di valore della proprietà, il valore |
//| CHART_SCALE_PT_PER_BAR deve essere preliminarmente impostato su true. //| |
//+-------------------------------------------------------------------------------+
bool (const double value,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_PRICE_MIN restituisce il valore del minimo del chart.

//+-------------------------------------------------------------------------------+
//| Ottiene il valore minimo del chart nella finestra principale (o sottofinestra) |
//+-------------------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }

CHART_PRICE_MAX resituisce il valore del massimo del chart.

//+-------------------------------------------------------------------------------+
//| Ottiene il valore massimo del chart nella finestra principale (o sottofinestra)|
//+-------------------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- prepara la variabile per ottenere il risultato
   double result=EMPTY_VALUE;
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- restituisce il valore della proprietà chart
   return(result);
  }

CHART_COMMENT – commento sul chart.

//+--------------------------------------------------------------------------------+
//| Ottiene il commento nell'angolo superiore sinitro del chart |
//+--------------------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- ricevere il valore della proprietà
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Ottiene il commento nell'angolo superiore sinitro del chart |
//+--------------------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- resetta il valore dell' errore
   ResetLastError();
//--- imposta il valore della proprietà
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- visualizza il messaggio di errore nel journal Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- esecuzione avvenuta
   return(true);
  }

CHART_IS_MAXIMIZED - la finestra del chart è massimizzata.

//+------------------------------------------------------------------+
//| Definisce se la finestra corrente del chart è massimizzata       |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- prepara la variabile per ricevere il valore della proprietà
   long value;
//--- resetta il valore dell'errore
   ResetLastError();
//--- riceve il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- mostra un messaggio d'errore nel log degli Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà del chart nella variabile
   result=value;
//--- esecuzione con successo
   return(true);
  }

CHART_IS_MINIMIZED – la finestra chart è minimizzata.

//+------------------------------------------------------------------+
//| Definisce se la finestra corrente del chart è massimizzata       |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- prepara la variabile per ricevere il valore della proprietà
   long value;
//--- resetta il valore dell'errore
   ResetLastError();
//--- riceve il valore della proprietà
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- mostra l'errore del messaggio nel log dell'Expert
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizza il valore della proprietà del chart nella variabile
   result=value;
//--- esecuzione con successo
   return(true);
  }

Pannello per le proprietà del chart

//--- connette la libreria di elementi di controllo
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- costanti predefinite
#define X_PROPERTY_NAME_1    10  // coordinate x del nome della proprietà nella prima colonna
#define X_PROPERTY_VALUE_1   225 // coordinate x del valore della proprietà nella prima colonna
#define X_PROPERTY_NAME_2    345 // coordinate x del nome della proprietà nella seconda e terza colonna
#define X_PROPERTY_VALUE_2   550 // coordinate x del valore della proprietà nella seconda e terza colonna
#define X_BUTTON_1           285 // coordinate x del bottone nella prima colonna
#define X_BUTTON_2           700 // coordinate x del bottone nella seconda colonna
#define Y_PROPERTY_1         30  // coordinate y dell'inizio della prima e seconda colonna
#define Y_PROPERTY_2         286 // coordinate y dell'inizion della terza colonna
#define Y_DISTANCE           16  // distanza assiale y tra le linee
#define LAST_PROPERTY_NUMBER 111 // numero dell'ultima proprietà grafica
//--- parametri di input
input color InpFirstColor=clrDodgerBlue; // Colore delle righe dispari
input color InpSecondColor=clrGoldenrod; // Colore delle righe pari
//--- variabili ed arrays
CChartObjectLabel  ExtLabelsName[];  // etichetta per visualizzazione dei nomi delle proprietà
CChartObjectLabel  ExtLabelsValue[]; // etichetta per visualizzazione dei valori delle proprietà
CChartObjectButton ExtButtons[];     // bottoni
int                ExtNumbers[];     // indici delle proprietà
string             ExtNames[];       // nomi delle proprietà
uchar              ExtDataTypes[];   // tipi di dato delle proprietà (integer, double, string)
uint               ExtGroupTypes[];  // array che memorizza i dati sulla appartenenza delle proprietà ad uno dei gruppi
uchar              ExtDrawTypes[];   // array che memorizza i dati sul tipo di proprietà display
double             ExtMaxValue[];    // massimo valori delle proprietà che sono possibili quando si lavora con il pannello
double             ExtMinValue[];    // minimi valori delle proprietà che sono possibili quando si lavora con il pannello
double             ExtStep[];        // steps per il cambio delle proprietà
int                ExtCount;         // numero totale di tutte le proprietà
color              ExtColors[2];     // array di colori per la visualizzazione delle righe
string             ExtComments[2];   // array di commenti (per la priprietà CHART_COMMENT)
//+--------------------------------------------------------------------------------+
//| Funzione di inizializzazione Indicatore Personalizzato  |
//+--------------------------------------------------------------------------------+
int OnInit()
  {
//--- visualizza un commento sul grafico
   Comment("SomeComment");
//--- memorizza i colori nell'array per potervi passare tra essi in un secondo momento
   ExtColors[0]=InpFirstColor;
   ExtColors[1]=InpSecondColor;
//--- memorizza i commenti nell'array per potervi passare tra essi in un secondo momento
   ExtComments[0]="FirstComment";
   ExtComments[1]="SecondComment";
//--- prepara e visualizza il pannello di controllo per la gestione delle proprietà del chart
   if(!PrepareControls())
      return(INIT_FAILED);
//--- esecuzione avvenuta
   return(INIT_SUCCEEDED);
  }
//+--------------------------------------------------------------------------------+
//| Funzione deinizializzazione dell'expert |
//+--------------------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- rimuove il commento sul chart
   Comment("");
  }
//+--------------------------------------------------------------------------------+
//| Handler di un evento chart |
//+--------------------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- controlla l'evento del clic sull'oggetto chart
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- divide il nome dell'oggetto per separatore
      string obj_name[];
      StringSplit(sparam,'_',obj_name);
      //--- controlla se l'oggetto è un bottone
      if(obj_name[0]=="Button")
        {
         //--- riceve l'indice del bottone
         int index=(int)StringToInteger(obj_name[1]);
         //--- rilascia il bottone
         ExtButtons[index].State(false);
         //--- imposta il nuovo valore della proprietà a seconda del suo tipo
         if(ExtDataTypes[index]=='I')
            ChangeIntegerProperty(index);
         if(ExtDataTypes[index]=='D')
            ChangeDoubleProperty(index);
         if(ExtDataTypes[index]=='S')
            ChangeStringProperty(index);
        }
     }
//--- ri-disegna i valori delle proprietà
   RedrawProperties();
   ChartRedraw();
  }
//+--------------------------------------------------------------------------------+
//| Cambia la proprietà integer del chart                             |
//+--------------------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
  {
//--- riceve il valore corrente della proprietà
   long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index]);
//--- definisce il seguente valore della proprietà
   switch(ExtDrawTypes[index])
     {
      case 'C':
         value=GetNextColor((color)value);
         break;
      default:
         value=(long)GetNextValue((double)value,index);
         break;
     }
//--- imposta il nuovo valore della proprietà
   ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index],0,value);
  }
//+--------------------------------------------------------------------------------+
//| Cambia la proprietà double del chart |
//+--------------------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
  {
//--- riceve il valore corrente della proprietà
   double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index]);
//--- definisce il seguente valore della proprietà
   value=GetNextValue(value,index);
//--- imposta il nuovo valore della proprietà
   ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index],value);
  }
//+--------------------------------------------------------------------------------+
//| Cambia la proprietà string del chart |
//+--------------------------------------------------------------------------------+
void ChangeStringProperty(const int index)
  {
//--- variabile statica per il passaggio all'interno dell'array ExtComments
   static uint comment_index=1;
//--- indice di cambiamento per ricevere un altro commento
   comment_index=1-comment_index;
//--- imposta il nuovo valore della proprietà
   ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[index],ExtComments[comment_index]);
  }
//+--------------------------------------------------------------------------------+
//| Ottiene il prossimo valore della proprietà |
//+--------------------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
  {
   if(value+ExtStep[index]<=ExtMaxValue[index])
      return(value+ExtStep[index]);
   else
      return(ExtMinValue[index]);
  }
//+--------------------------------------------------------------------------------+
//| Ottiene il prossimo colore per la proprietà di tipo colore       |
//+--------------------------------------------------------------------------------+
color GetNextColor(const color clr)
  {
//--- restituisce i seguenti valori del colore
   switch(clr)
     {
      case clrWhite: return(clrRed);
      case clrRed:   return(clrGreen);
      case clrGreen: return(clrBlue);
      case clrBlue:  return(clrBlack);
      default:       return(clrWhite);
     }
  }
//+--------------------------------------------------------------------------------+
//| Re-disegna i valori della proprietà                              |
//+--------------------------------------------------------------------------------+
void RedrawProperties(void)
  {
//--- testo valore della proprietà
   string text;
   long   value;
//--- loop del numero delle proprietà
   for(int i=0;i<ExtCount;i++)
     {
      text="";
      switch(ExtDataTypes[i])
        {
         case 'I':
            //--- riceve il corrente valore della proprietà
            if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[i],0,value))
            break;
            //--- testo integer della proprietà
            switch(ExtDrawTypes[i])
              {
               //--- proprietà colore
               case 'C':
                  text=(string)((color)value);
                  break;
                  //--- proprietà booleana
               case 'B':
                  text=(string)((bool)value);
                  break;
                  //--- proprietà di enumerazione ENUM_CHART_MODE
               case 'M':
                  text=EnumToString((ENUM_CHART_MODE)value);
                  break;
                  //--- proprietà di enumerazione ENUM_CHART_VOLUME_MODE
               case 'V':
                  text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
                  break;
                  //--- numero tipo int
               default:
                  text=IntegerToString(value);
                  break;
              }
            break;
         case 'D':
            //--- testo proprietà double
            text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[i]),4);
            break;
         case 'S':
            //--- testo proprietà string
            text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[i]);
            break;
        }
      //--- valore della prorpietà display
      ExtLabelsValue[i].Description(text);
     }
  }
//+--------------------------------------------------------------------------------+
//| Crea il pannello per gestire le proprietà del chart |
//+--------------------------------------------------------------------------------+
bool PrepareControls(void)
  {
//--- alloca la memoria per array con una riseva
   MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- variabili
   int i=0;     // variable loop
   int col_1=0; // numero di proprietà nella prima colonna
   int col_2=0; // numero di proprietà nella seconda colonna
   int col_3=0; // numero di proprietà nella terza colonna
//--- numero corrente della proprità - 0
   ExtCount=0;
//--- visualizzazione per le proprietà nel loop
   while(i<=LAST_PROPERTY_NUMBER)
     {
      //--- immagazzina il corrente numero della proprietà
      ExtNumbers[ExtCount]=i;
      //--- incrementa il valore della variabile loop
      i++;
      //--- controlla se c'è una proprietà con tale numero
      if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
        {
         //--- crea elementi di controllo per la proprietà
         switch(ExtGroupTypes[ExtCount])
           {
            case 1:
               //--- crea etichette d un bottone per la proprietà
               if(!ShowProperty(ExtCount,0,X_PROPERTY_NAME_1,X_PROPERTY_VALUE_1,X_BUTTON_1,Y_PROPERTY_1+col_1*Y_DISTANCE,true))
               return(false);
               //--- il numero degli elementi nella prima colonna è aumentato
               col_1++;
               break;
            case 2:
               //--- crea etichette d un bottone per la proprietà
               if(!ShowProperty(ExtCount,1,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,X_BUTTON_2,Y_PROPERTY_1+col_2*Y_DISTANCE,true))
               return(false);
               //--- il numero degli elementi nella seconda colonna è aumentato
               col_2++;
               break;
            case 3:
               //--- crea solo etichette per la proprietà
               if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,false))
               return(false);
               //--- il numero degli elementi nella terza colonna è aumentato
               col_3++;
               break;
           }
         //--- definisce il valore della proprietà massimo e minimo e lo step
         GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
         //--- incrementa il numero delle proprietà
         ExtCount++;
        }
     }
//--- libera la memoria non usata dagli array
   MemoryAllocation(ExtCount);
//--- ri-disegna i valori delle proprietà
   RedrawProperties();
   ChartRedraw();
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Alloca la memoria per gli array |
//+--------------------------------------------------------------------------------+
void MemoryAllocation(const int size)
  {
   ArrayResize(ExtLabelsName,size);
   ArrayResize(ExtLabelsValue,size);
   ArrayResize(ExtButtons,size);
   ArrayResize(ExtNumbers,size);
   ArrayResize(ExtNames,size);
   ArrayResize(ExtDataTypes,size);
   ArrayResize(ExtGroupTypes,size);
   ArrayResize(ExtDrawTypes,size);
   ArrayResize(ExtMaxValue,size);
   ArrayResize(ExtMinValue,size);
   ArrayResize(ExtStep,size);
  }
//+--------------------------------------------------------------------------------+
//| Controlla se l'indice della proprietà appartiene ad uno di quelli dell' |
//| enumerazioni ENUM_CHART_PROPERTIES                             |
//+--------------------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
  {
//--- controllare se la proprietà è di tipo integer
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind);
   if(_LastError==0)
     {
      data_type='I';                      // proprietà dall'enumerazione ENUM_CHART_PROPERTY_INTEGER
      GetTypes(ind,group_type,draw_type); // definisce i parametri della proprietà display
      return(true);
     }
//--- controllare se la proprietà è di tipo double
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind);
   if(_LastError==0)
     {
      data_type='D';                      // proprietà dall' enumerazione ENUM_CHART_PROPERTY_DOUBLE
      GetTypes(ind,group_type,draw_type); // definisce i parametri della proprietà display
      return(true);
     }
//--- controlla se la proprietà è di tipo stringa
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind);
   if(_LastError==0)
     {
      data_type='S';                      // proprietà dall'enumerazione ENUM_CHART_PROPERTY_STRING
      GetTypes(ind,group_type,draw_type); // definisce i parametri della proprietà display
      return(true);
     }
//--- la proprietà non corrisponde a nessuna enumerazione
   return(false);
  }
//+--------------------------------------------------------------------------------+
//| Definisce il gruppo nel quale la proprietà dev'essere memorizzata |
//| così come il tipo della sua visualizzazione |
//+--------------------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- controlla se la proprietà appartiene al terzo gruppo
//--- le proprietà del terzo gruppo vengono visualizzate nella seconda colonna a partire da CHART_BRING_TO_TOP
   if(CheckThirdGroup(property_number,group_type,draw_type))
      return;
//--- controlla se la proprietà appartiene al secondo gruppo
//--- le proprietà del secondo gruppo sono visualizzate all'inizio della seconda colonna
   if(CheckSecondGroup(property_number,group_type,draw_type))
      return;
//---se vi trovate qui, la proprietà appartiene al primo gruppo (prima colonna)
   CheckFirstGroup(property_number,group_type,draw_type);
  }
//+-------------------------------------------------------------------------------+
//| Controlla se la proprietà appartiene al terzo gruppo e |
//| definisce il suo tipo di visualizzazione in caso di risposta positiva |
//+-------------------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- controlla se la proprietà appartiene al terzo gruppo
   switch(property_number)
     {
      //--- proprietà booleane
      case CHART_IS_OBJECT:
      case CHART_WINDOW_IS_VISIBLE:
         draw_type='B';
         break;
         //--- proprietà integer
      case CHART_VISIBLE_BARS:
      case CHART_WINDOWS_TOTAL:
      case CHART_WINDOW_HANDLE:
      case CHART_WINDOW_YDISTANCE:
      case CHART_FIRST_VISIBLE_BAR:
      case CHART_WIDTH_IN_BARS:
      case CHART_WIDTH_IN_PIXELS:
         draw_type='I';
         break;
         //--- proprietà double
      case CHART_PRICE_MIN:
      case CHART_PRICE_MAX:
         draw_type='D';
         break;
         //--- in realtà, questa proprietà è un comando di visualizzazione del chart in cima a tutti gli altri
         //--- non vi è alcuna necessità di applicare questo pannello, siccome la finestra sarà sempre
         //--- in cima ad altre prima che noi la usiamo
      case CHART_BRING_TO_TOP:
         draw_type=' ';
         break;
         //--- la proprietà non appartiene al terzo gruppo
      default:
         return(false);
     }
//--- la proprietà appartiene al terzo gruppo
   group_type=3;
   return(true);
  }
//+-------------------------------------------------------------------------------+
//| Controlla se la proprietà appartiene al secondo gruppo e |
//| definisce il suo tipo di visualizzazione in caso di risposta positiva |
//+-------------------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- controlla se la proprietà appartiene al secondo gruppo
   switch(property_number)
     {
      //--- ENUM_CHART_MODE type property
      case CHART_MODE:
         draw_type='M';
         break;
         //--- ENUM_CHART_VOLUME_MODE type property
      case CHART_SHOW_VOLUMES:
         draw_type='V';
         break;
         //--- proprietà stringa
      case CHART_COMMENT:
         draw_type='S';
         break;
         //--- proprietà color
      case CHART_COLOR_BACKGROUND:
      case CHART_COLOR_FOREGROUND:
      case CHART_COLOR_GRID:
      case CHART_COLOR_VOLUME:
      case CHART_COLOR_CHART_UP:
      case CHART_COLOR_CHART_DOWN:
      case CHART_COLOR_CHART_LINE:
      case CHART_COLOR_CANDLE_BULL:
      case CHART_COLOR_CANDLE_BEAR:
      case CHART_COLOR_BID:
      case CHART_COLOR_ASK:
      case CHART_COLOR_LAST:
      case CHART_COLOR_STOP_LEVEL:
         draw_type='C';
         break;
         //--- la proprietà non appartiene al secondo gruppo
      default:
         return(false);
     }
//--- la proprietà appartiene al secondo gruppo
   group_type=2;
   return(true);
  }
//+-------------------------------------------------------------------------------------+
//| Chiamato solo se è si sa già che la proprietà non appartiene |
//| al secondo e terzo gruppo proprietà |
//+-------------------------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- la proprietà appartiene al primo gruppo
   group_type=1;
//--- definisce il tipo di proprietà display
   switch(property_number)
     {
      //--- proprietà integer
      case CHART_SCALE:
      case CHART_HEIGHT_IN_PIXELS:
         draw_type='I';
         return;
         //--- proprietà double
      case CHART_SHIFT_SIZE:
      case CHART_FIXED_POSITION:
      case CHART_FIXED_MAX:
      case CHART_FIXED_MIN:
      case CHART_POINTS_PER_BAR:
         draw_type='D';
         return;
         //--- solo le proprietà booleane sono rimaste
      default:
         draw_type='B';
         return;
     }
  }
//+--------------------------------------------------------------------------------+
//| Crea l'etichetta ed il bottone per la proprietà |
//+--------------------------------------------------------------------------------+
bool ShowProperty(const int ind,const int type,const int x1,const int x2,
                  const int xb,const int y,const bool btn)
  {
//--- Array statico per la commutazione all'interno di array di colore ExtColors
   static uint color_index[3]={1,1,1};
//--- indice di cambiamento per la ricezione di un altro colore
   color_index[type]=1-color_index[type];
//--- mostra le etichette ed un bottone (se btn=true) per la proprietà
   if(!LabelCreate(ExtLabelsName[ind],"name_"+(string)ind,ExtNames[ind],ExtColors[color_index[type]],x1,y))
      return(false);
   if(!LabelCreate(ExtLabelsValue[ind],"value_"+(string)ind,"",ExtColors[color_index[type]],x2,y))
      return(false);
   if(btn && !ButtonCreate(ExtButtons[ind],(string)ind,xb,y+1))
      return(false);
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Crea etichette                                                    |
//+--------------------------------------------------------------------------------+
bool LabelCreate(CChartObjectLabel &lbl,const string name,const string text,
                 const color clr,const int x,const int y)
  {
   if(!lbl.Create(0,"Label_"+name,0,x,y)) return(false);
   if(!lbl.Description(text))             return(false);
   if(!lbl.FontSize(10))                  return(false);
   if(!lbl.Color(clr))                    return(false);
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Crea bottoni |
//+--------------------------------------------------------------------------------+
bool ButtonCreate(CChartObjectButton &btn,const string name,
                  const int x,const int y)
  {
   if(!btn.Create(0,"Button_"+name,0,x,y,50,15)) return(false);
   if(!btn.Description("Next"))                  return(false);
   if(!btn.FontSize(10))                         return(false);
   if(!btn.Color(clrBlack))                      return(false);
   if(!btn.BackColor(clrWhite))                  return(false);
   if(!btn.BorderColor(clrBlack))                return(false);
//--- esecuzione avvenuta
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Definisce il massimo ed il minimo valore e step delle proprietà |
//+--------------------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
  {
   double value;
//--- imposta i valori a seconda del tipo di proprietà
   switch(property_number)
     {
      case CHART_SCALE:
         max=5;
         min=0;
         step=1;
         break;
      case CHART_MODE:
      case CHART_SHOW_VOLUMES:
         max=2;
         min=0;
         step=1;
         break;
      case CHART_SHIFT_SIZE:
         max=50;
         min=10;
         step=2.5;
         break;
      case CHART_FIXED_POSITION:
         max=90;
         min=0;
         step=15;
         break;
      case CHART_POINTS_PER_BAR:
         max=19;
         min=1;
         step=3;
         break;
      case CHART_FIXED_MAX:
         value=ChartGetDouble(0,CHART_FIXED_MAX);
         max=value*1.25;
         min=value;
         step=value/32;
         break;
      case CHART_FIXED_MIN:
         value=ChartGetDouble(0,CHART_FIXED_MIN);
         max=value;
         min=value*0.75;
         step=value/32;
         break;
      case CHART_HEIGHT_IN_PIXELS:
         max=700;
         min=520;
         step=30;
         break;
         //--- valori default
      default:
         max=1;
         min=0;
         step=1;
     }
  }

Rappresentazione Grafico

Costanti Oggetti