Nachschlagewerk MQL5Konstanten, Enumerationen und StrukturenChartkonstantenBeispiele von Arbeiten mit dem Chart

Beispiele von Operationen mit dem Chart

Dieser Abschnitt enthält Beispiele für die Eigenschaften des Charts. Für jede Eigenschaft gibt es hier ein oder zwei komplette Funktionen, die den Wert dieser Eigenschaft eingeben/erhalten erlauben. Diese Funktionen können in Ihrer MQL5 Programme verwendet werden.

Die Abbildung zeigt eine grafische Panel, die zeigt, wie Veränderung des Charts sein Aussehen ändert. Ein Klick auf "Next" erlaubt es Ihnen den neuen Wert der jeweiligen Eigenschaft einzugeben und die Änderungen im Chart sehen.

chart_properties_panel

Quellcode der Panel ist unten.

Chart-Eigenschaften und Beispiele von Funktionen für Arbeit mit ihnen

CHART_IS_OBJECT – bestimmt, ob das Objekt ein Chart oder ein grafisches Objekt ist.

//+------------------------------------------------------------------+
//| Die Ermittlung, ob das Objekt ein Chart ist. Wenn es             |
//| ein grafisches Objekt ist, ist das Ergebnis true. Wenn es ein    |
//| Chart ist, wird das Variable result false gesetzt werden.        |
//+------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten die Eigenschaft des Charts
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      //--- false zurückgeben
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_BRING_TO_TOP – zeigt ein Chart über alle anderen.

//+------------------------------------------------------------------+
//| Senden Befehl dem Terminal, Chart über alle anderen zu zeigen.   |
//+------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Zeigt wir den Chart über alle anderen
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_MOUSE_SCROLL – Eigenschaft von Chart-Scroll mit der linken Maustaste.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob Scroll des Charts mit der             |
//| linken Maustaste möglich ist.                                    |
//+------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Scroll mit der linken Tasten  |
//| möglich ist.                                                     |
//+------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_EVENT_MOUSE_MOVE – Eigenschaft der Sendung von Nachrichten über Ereignisse der Bewegung und Klicken an den MQL5-Programmen (CHARTEVENT_MOUSE_MOVE).

//+------------------------------------------------------------------+
//| Werden die Nachrichten über Ereignisse der Bewegung und Klicken  |
//| an allen MQL5-Programmen auf diesem Chart gesendet?              |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert das Senden von Nachrichten    |
//| über Ereignisse von Bewegung und Klicken an allen                |
//| MQL5-Programmen auf diesem Chart.                                |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_EVENT_OBJECT_CREATE – Eigenschaft der Sendung von Nachrichten über Ereignisse der Erstellung des grafischen Objektes an den MQL5-Programmen (CHARTEVENT_OBJECT_CREATE).

//+------------------------------------------------------------------+
//| Werden die Nachrichten über Ereignisse der Erstellung eines      |
//| Objektes an allen MQL5-Programmen auf diesem Chart gesendet?     |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert das Senden von Nachrichten    |
//| über Ereignisse von Erstellung eines grafischen Objektes an allen|
//| MQL5-Programmen auf diesem Chart.                                |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_EVENT_OBJECT_DELETE – Eigenschaft der Sendung von Nachrichten über Ereignisse der Löschung des grafischen Objektes an den MQL5-Programmen (CHARTEVENT_OBJECT_DELETE).

//+------------------------------------------------------------------+
//| Die Nachrichten über Ereignisse der Löschung eines grafischen    |
//| Objektes an allen MQL5-Programmen auf diesem Chart zu senden?    |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert das Senden von Nachrichten    |
//| über Ereignisse von Löschung eines grafischen Objektes an allen  |
//| MQL5-Programmen auf diesem Chart.                                |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_MODE – Typ des Charts (Kerzen, Bars oder eine Linie).

//+------------------------------------------------------------------+
//| Bekommen wir den Typ des Charts (in Form von Kerzen, Bars oder   |
//| einer Linie).                                                    |
//+------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=WRONG_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((ENUM_CHART_MODE)result);
  }
//+------------------------------------------------------------------+
//| Setzen den Typ des Charts (in Form von Kerzen, Bars oder         |
//| einer Linie).                                                    |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_FOREGROUND – Eigenschaft der Anzeige vom Preischart im Vordergrund.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob das Preischart im Vordergrund         |
//| angezeigt wird.                                                  |
//+------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige des Preischarts im    |
//| Vordergrund.                                                     |
//+------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHIFT – Modus von der Verschiebung des Preischarts vom rechten Rand.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Anzeigemodus des Charts mit  |
//| Verschiebung vom rechten Rand aktiv ist.                         |
//+------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige des Preischarts mit   |
//| Verschiebung vom rechten Rand.                                   |
//+------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_AUTOSCROLL – Modus der automatischen Scrollen an den rechten Rand des Charts.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob den Modus der automatischen Scrollen  |
//| des Charts nach rechts, wenn neue Ticks empfangen werden,        |
//| aktiv ist.                                                       |
//+------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die automatische Scrollen     |
//| des Charts nach rechts, wenn neue Ticks empfangen werden.        |
//+------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SCALE – Eigenschaft der Chart-Skala.

//+------------------------------------------------------------------+
//| Bekommen die Skala des Charts (0 bis 5).                         |
//+------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Setzen die Skala des Charts (0 bis 5).                           |
//+------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SCALEFIX – Modus der festen Skala des Charts.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Modus der festen Skala aktiv ist. |
//+------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die feste Skala               |
//+------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SCALEFIX_11 – Modus der Chartskala 1:1.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Modus der Skala "1:1" aktiv ist.  |
//+------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die Skala "1:1"               |
//+------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SCALE_PT_PER_BAR – Modus der Eingabe der Skala in Punkten pro Bar.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Eingabemodus der Skala       |
//| in Punkten  pro Bar aktiv ist.                                   |
//+------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Modus der Eingabe der Skala   |
//| in Punkten pro Bar.                                              |
//+------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_OHLC – Eigenschaft der Anzeige der Werten OHLC in der linken oberen Ecke.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Anzeigemodus von OHLC-Werten      |
//| in der linken oberen Ecke aktiv ist.                             |
//+------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Werten OHLC in der|
//| linken oberen Ecke des Charts.                                   |
//+------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_BID_LINE – Eigenschaft der Anzeige des Bid-Wertes als eine horizontale Linie auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt der Modus der Anzeige der Bid-Linie       |
//| auf dem Chart.                                                   |
//+------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Bid-Linie auf dem |
//| Chart.                                                           |
//+------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_ASK_LINE – Eigenschaft der Anzeige des Ask-Wertes als eine horizontale Linie auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt die Modus der Anzeige der Ask-Linie       |
//| auf dem Chart.                                                   |
//+------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Ask-Linie auf dem |
//| Chart.                                                           |
//+------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_LAST_LINE – Eigenschaft der Anzeige des Last-Wertes als eine horizontale Linie auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Anzeigemodus der Linie für   |
//| den Preis der letzten Transaktion aktiv ist.                     |
//+------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Linie des Preises |
//| der letzten Transaktion.                                         |
//+------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_PERIOD_SEP – Eigenschaft der Anzeige der vertikalen Teilern zwischen benachbarten Perioden.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt den Anzeigemodus der vertikalen      |
//| Teilern zwischen benachbarten Perioden.                          |
//+------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die Anzeige der vertikalen    |
//| Teilern zwischen benachbarten Perioden.                          |
//+------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_GRID – Eigenschaft der Anzeige des Chartrasters.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob der Chartraster angezeigt wird.       |
//+------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert den Chartraster.              |
//+------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_VOLUMES – Eigenschaft der Anzeige der Volumen auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob die Volumen auf dem Chart angezeigt   |
//| werden (werden nicht angezeigt, Tick-Volumen angezeigt werden,   |
//| reale Volumen angezeigt werden).                                 |
//+------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=WRONG_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt den Modus der Anzeige der Volumina            |
//| auf dem Chart.                                                   |
//+------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_OBJECT_DESCR – Eigenschaft der Pop-up-Beschreibungen von grafischen Objekten.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob die Pop-up-Beschreibungen der         |
//| grafischen Objekten angezeigt werden, wenn Sie mit dem Mauszeiger|
//| auf ihnen deuten.                                                |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die Anzeige der               |
//| Popup-Beschreibungen der grafischen Objekten wenn Sie mit dem Mauszeiger auf ihnen deuten. |
//| Popup-Beschreibungen der grafischen Objekten wenn Sie mit dem Mauszeiger auf ihnen deuten. |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_VISIBLE_BARS – ermittelt die Anzahl der Baren auf dem Chart, die zur Anzeige verfügbar sind.

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Anzahl der Bars, die angezeigt  wird    |
//| im Chart-Fenster.                                                |
//+------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_WINDOWS_TOTAL – ermittelt die Gesamtzahl der Chart-Fenster, einschließlich Unterfenster der Indikatoren.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Gesamtzahl der Chart-Fenster             |
//| der Indikatoren.                                                 |
//+------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_WINDOW_IS_VISIBLE – ermittelt die Sichtbarkeit des Unterfensters.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt,ob ein Fenster oder Unterenster des Charts|
//| sichtbar ist.                                                    |
//+------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_WINDOW_HANDLE – gibt ein Handle des Charts zurück.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Handle des Charts                        |
//+------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_WINDOW_YDISTANCE – ermittelt den Abstand in Pixel zwischen dem oberen Rahmen des Indikator-Unterfensters und dem oberen Rahmen des Hauptfensters des Charts.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Abstand in Pixel zwischen dem oberen     |
//| Rahmen des Unterfensters und oberen Rahmen des Hauptfensters.    |
//+------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_FIRST_VISIBLE_BAR – gibt den Nummer des ersten sichtbaren Bars auf dem Chart zurück (Indizierung der Baren wie in Zeitreihe).

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Nummer des ersten sichtbaren Bars des Charts
//| Indexing als in Zeitreihe, dass die letzten Bars kleineren Indizes haben
//+------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_WIDTH_IN_BARS – gibt die Breite des Chart in den Baren zurück.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Wert der Breite des Charts in den Baren  |
//+------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_WIDTH_IN_PIXELS – gibt die Breite des Chart in den Pixeln zurück.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Wert der Breite des Charts in Pixeln     |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }

CHART_HEIGHT_IN_PIXELS – Eigenschaft der Höhe des Charts in Pixeln.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Wert der Höhe des Charts in Pixeln       |
//+------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long result=-1;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt den Wert der Höhe des Charts in Pixeln        |
//+------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_BACKGROUND – Farbe von Hintergrund des Charts.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Hintergrundfarbe des Charts              |
//+------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir die Hintergrundfarbe des Charts
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Hintergrundfarbe des Charts               |
//+------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Setzen wir die Hintergrundfarbe des Charts
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_FOREGROUND – Farbe der Achse, Skala und OHLC Zeile.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe der Achse, Skala und OHLC Zeile    |
//+------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir die Farbe der Achse, Skala und OHLC Zeile
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe der Achse, Skala und OHLC Zeile     |
//+------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Setzen wir die Farbe der Achse, Skala und OHLC Zeile
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_GRID – Farbe des Chart-Gitters.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe des Gitters des Charts             |
//+------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten die Farbe des Chart-Gitters
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe des Gitters des Charts              |
//+------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Setzen wir die Farbe des Chart-Gitters
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_VOLUME – Farbe der Volumen und Ebenen der Öffnung der Positionen.

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Farbe Volumen oder Ebenen der Öffnung   |
//| der Positionen.                                                  |
//+------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir die Farbe der Volumen und Ebenen der Öffnung der Positionen
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe Volumen oder Ebenen der Öffnung     |
//| der Positionen.                                                  |
//+------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Setzen wir die Farbe der Volumen und Ebenen der Öffnung der Positionen
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_CHART_UP – Farbe des Bars nach oben, Schatten und Kanten des Körpers von Bull-Kerze.

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Farbe des Bars nach oben, die Farbe     |
//| der Schatten und Kanten des Körpers von Bull-Kerze               |
//+------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe des Bars nach oben, Schatten und Kanten des Körpers von Bull-Kerze
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe des Bars nach oben, die Farbe       |
//| der Schatten und Kanten des Körpers von Bull-Kerze               |
//+------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe des Bars nach oben, Schatten und Kanten des Körpers von Bull-Kerze
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_CHART_DOWN – Farbe des Bars nach unten, Schatten und Kanten des Körpers von Bär-Kerze.

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Farbe des Bars nach unten, die Farbe    |
//| der Schatten und Kanten des Körpers von Bär-Kerze                |
//+------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe des Bars nach unten, Schatten und Kanten des Körpers von Bär-Kerze
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe des Bars nach unten, die Farbe      |
//| der Schatten und Kanten des Körpers von Bär-Kerze                |
//+------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe des Bars nach unten, Schatten und Kanten des Körpers von Bär-Kerze
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_CHART_LINE – Farbe der Linie des Charts und Kerzen "Doji".

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe der Linie des Charts und Kerzen "Doji"
//+------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir die Farbe der Linie des Charts und Kerzen "Doji"
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe der Linie des Charts und Kerzen     |
//| "Doji".                                                          |
//+------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Setzen wir die Farbe der Linie des Charts und Kerzen "Doji"
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_CANDLE_BULL – Farbe des Körpers von Bull-Kerze.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe des Körpers von Bull-Kerze         |
//+------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe des Körpers von Bull-Kerze
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe des Körpers von Bull-Kerze          |
//+------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe des Körpers von Bull-Kerze
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_CANDLE_BEAR – Farbe des Körpers von Bär-Kerze.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe des Körpers von Bär-Kerze          |
//+------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe des Körpers von Bär-Kerze
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe des Körpers von Bär-Kerze           |
//+------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe des Körpers von Bär-Kerze
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_BID – Farbe der Linie des Bid-Preises.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe der Bid-Linie                      |
//+------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe der Bid-Linie
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
    ;}
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
;}
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe der Bid-Linie                       |
//+------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe der Bid-Linie
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_ASK – Farbe der Linie des Ask-Preises.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe der Ask-Linie                      |
//+------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe der Ask-Linie
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe der Ask-Linie                       |
//+------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe der Ask-Linie
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
    ;}
//--- erfolgreiche Ausführung
   return(true);
}

CHART_COLOR_LAST – Farbe der Linie von letzten Transaktion (Last).

//+------------------------------------------------------------------+
//| Die Funktion erhält die Farbe der Linie von letzten Transaktion  |
//+------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe der Linie von letzten Transaktion (Last)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe der Linie von letzten               |
//| Transaktion.                                                     |
//+------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe der Linie von letzten Transaktion (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_COLOR_STOP_LEVEL – Farbe von Stop-Orders (Stop Loss und Take Profit).

//+------------------------------------------------------------------+
//| Die Funktion bekommt die Farbe von Stop Loss und Take Profit     |
//+------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um die Farbe zu erhalten
   long result=clrNONE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- erhalten die Farbe von Stop Loss und Take Profit.
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Farbe von Stop Loss und Take Profit       |
//+------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- setzen die Farbe von Stop Loss und Take Profit.
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_TRADE_LEVELS – Eigenschaft der Anzeige von Handelsstufen auf dem Chart (Stufen der offenen Positionen, Stop Loss, Take Profit und Pending Orders).

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob die Handelsstufen auf dem Chart angezeigt werden
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert die Anzeige der Handelsstufen |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_DRAG_TRADE_LEVELS – Eigenschaft von Ziehen der Handelsstufen auf dem Chart mit dem Maus.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob Ziehen von Handelsstufen auf dem Chart|
//| mit dem Maus erlaubt ist.                                        |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Ziehen der Handelsstufen      |
//| auf dem Chart mit dem Maus.                                      |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_DATE_SCALE – Eigenschaft der Anzeige der Zeitskala auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob die Zeitskala auf dem Chart angezeigt wird
//+------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Zeitskala auf dem |
//| Chart.                                                           |
//+------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_PRICE_SCALE – Eigenschaft der Anzeige der Preiseskala auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob die Preiseskala auf dem Chart angezeigt wird
//+------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um den Wert der Eigenschaft zu erhalten
   long value;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- speichern den Wert der Chat-Eigenschaft in der Variable
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert Anzeige der Preiseskala       |
//| auf dem  Chart                                                   |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHOW_ONE_CLICK – Anzeige des Panels für schnellen Handel auf dem Chart (Option "Ein-Klick-Handel").

//+------------------------------------------------------------------+
//| Die Funktion bestimmt, ob das Panel für schnellen Handel         |
//| ("Ein-Klick-Handel") auf dem Chart angezeigt wird                |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- Variable für die Erhaltung des Eigenschaftswertes vorbereiten
   long value;
//--- den Wert des Fehlers zurücksetzen
   ResetLastError();
//--- Eigenschaftswert erhalten
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- Fehlermeldung im Experten-Journal anzeigen
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- den Wert der Charteigenschaft in der Variablen speichern
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion aktiviert/deaktiviert den Anzeigemodus              |
//| des Handelspanels auf dem Chart                                  |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- den Wert des Fehlers zurücksetzen
   ResetLastError();
//--- Eigenschaftswert setzen
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- Fehlermeldung im Experten-Journal  anzeigen
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_SHIFT_SIZE – Verschiebung des Null-Baren vom rechten Rand in Prozent.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Größe der Verschiebung des Null-Baren    |
//| vom rechten Rand des Charts in Prozent (von 10% bis 50%).        |
//+------------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Größe der Verschiebung des Null-Baren     |
//| vom rechten Rand des Charts in Prozent (von 10% bis 50%). Um     |
//| den Modus der Verschiebung zu aktivieren, setzen Sie den Wert    |
//| von CHART_SHIFT auf true.                                        |
//+------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_FIXED_POSITION – Position der festen Position des Chart vom linken Rand als Prozentsatz.

//+------------------------------------------------------------------+
//| Die Funktion erhält die Position der festen Position des Chart   |
//| vom linken Rand als Prozentsatz.                                 |
//+------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt die Position der festen Position des Chart    |
//| vom linken Rand als Prozentsatz. Um die Position der feste       |
//| Position auf dem Chart zu sehen, muss man zunähst den Wert der   |
//| Eigenschaft CHART_AUTOSCROLL auf false setzen.                   |
//+------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_FIXED_MAX – die Eigenschaft des festen Maximalwertes des Charts.

//+------------------------------------------------------------------+
//| Die Funktion erhält den festen Maximalwert des Charts.           |
//+------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt den festen Maximalwert des Charts.            |
//| Um den Wert dieser Eigenschaft zu ändern, setzen Sie             |
//| zunächst den Wert der Eigenschaft CHART_SCALEFIX auf             |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_FIXED_MIN – Eigenschaft des festen Minimalwertes des Charts.

//+------------------------------------------------------------------+
//| Die Funktion erhält den festen Minimalwert des Charts            |
//+------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt den festen Minimalwert des Charts.            |
//| Um den Wert dieser Eigenschaft zu ändern, setzen Sie             |
//| zunächst den Wert der Eigenschaft CHART_SCALEFIX auf true.       |
//+------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_POINTS_PER_BAR – Skalenwert als Punkten pro Bar.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Skalenwert als Punkten pro Bar           |
//+------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }
//+------------------------------------------------------------------+
//| Die Funktion setzt den Skalenwert als Punkten pro Bar.           |
//| Um das Ergebnis von Veränderungen des Wertes dieser              |
//| Eigenschaft zu sehen, setzen Sie zunähst den Wert von            |
//| CHART_SCALE_PT_PER_BAR auf true.                                 |
//+------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_PRICE_MIN – gibt den Minimalwert des Charts zurück.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Minimalwert des Charts im Hauptfenster   |
//| oder Untenfenster.                                               |
//+------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }

CHART_PRICE_MAX – gibt den Maximalwert des Charts zurück.

//+------------------------------------------------------------------+
//| Die Funktion erhält den Maximalwert des Charts im Hauptfenster   |
//| oder Untenfenster.                                               |
//+------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- Bereiten wir eine Variable, um das Ergebnis zu erhalten
   double result=EMPTY_VALUE;
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- Geben den Wert der Eigenschaft zurück
   return(result);
  }

CHART_COMMENT – Text der Kommentar auf dem Chart.

//+------------------------------------------------------------------+
//| Die Funktion bekommt den Kommentartext in der linken oberen Ecke |
//| des Charts.                                                      |
//+------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Erhalten wir den Wert der Eigenschaft
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion bekommt den Kommentartext in der linken oberen Ecke |
//| des Charts.                                                      |
//+------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- Setzen den Wert des Fehlers zurück
   ResetLastError();
//--- Geben wir den Wert der Eigenschaft ein
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- Schreiben die Fehlermeldung in den Log "Experten"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_IS_MAXIMIZED – Chartfenster maximiert

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob das Chartfenster vergrößert ist       |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- bereiten wir eine Variable vor, um den Wert der Eigenschaft zu erhalten
   long value;
//--- setzen wir den Fehlerwert zurück
   ResetLastError();
//--- Wert der Eigenschaft erhalten
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- Fehlermeldung im Journal "Expert Advisors" ausgeben
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- den Wert der Eigenschaft in der Variablen speichern
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }

CHART_IS_MINIMIZED – Chartfenster minimiert

//+------------------------------------------------------------------+
//| Die Funktion ermittelt, ob das Chartfenster minimiert ist        |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- bereiten wir eine Variable vor, um den Wert der Eigenschaft zu erhalten
   long value;
//--- setzen wir den Fehlerwert zurück
   ResetLastError();
//--- den Wert der Eigenschaft erhalten
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- Fehlermeldung im Journal "Expert Advisor" anzeigen
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- den Wert der Eigenschaft in dewr Variablen speichern
   result=value;
//--- erfolgreiche Ausführung
   return(true);
  }

Panel für die Charteigenschaften

//--- Schließen Sie das Control-Bibliothek
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- Vordefinierte Konstanten
#define X_PROPERTY_NAME_1    10  // X-Koordinate der Eigenschaft Name in der ersten Spalte
#define X_PROPERTY_VALUE_1   225 // X-Koordinaten des Eigenschaftwertes in der ersten Spalte
#define X_PROPERTY_NAME_2    345 // X-Koordinate der Eigenschaft Name in der zweiten und dritten Spalte
#define X_PROPERTY_VALUE_2   550 // X-Koordinaten des Eigenschaftwertes in der zweiten und dritten Spalte
#define X_BUTTON_1           285 // X-Koordinate der Taste in der ersten Spalte
#define X_BUTTON_2           700 // X-Koordinate der Taste in der zweiten Spalte
#define Y_PROPERTY_1         30  // Y-Koordinate des Anfangspunktes von der ersten und zweiten Spalte
#define Y_PROPERTY_2         286 // Y-Koordinate des Anfangspunktes von der dritten Spalte
#define Y_DISTANCE           16  // Der y-axiale Abstand zwischen den Zeilen
#define LAST_PROPERTY_NUMBER 111 // Nummer der letzten grafischen Eigenschaften
//--- Input-Parameter
input color InpFirstColor=clrDodgerBlue; // Farbe der ungeraden Zeilen
input color InpSecondColor=clrGoldenrod; // Farbe der geraden Zeilen
//--- Variablen und Arrays
CChartObjectLabel  ExtLabelsName[];  // Label, um die Namen der Eigenschaften anzuzeigen
CChartObjectLabel  ExtLabelsValue[]; // Label, um die Namen der Werte anzuzeigen
CChartObjectButton ExtButtons[];     // Tasten
int                ExtNumbers[];     // Indizes der Eigenschaften
string             ExtNames[];       // Namen der Eigenschaften
uchar              ExtDataTypes[];   // Datentypen von Eigenschaften (integer, double, string)
uint               ExtGroupTypes[];  // Array, das Informationen über die Zubehör der Eigenschaften zu eine der Gruppen speichert
uchar              ExtDrawTypes[];   // Array, das Informationen über die Methode der Anzeige der Eigenschaften speichert
double             ExtMaxValue[];    // Maximale Werte der Eigenschaften, die sie in den Prozess der Arbeit mit diesem Paneel haben können
double             ExtMinValue[];    // Minimale Werte der Eigenschaften, die sie in den Prozess der Arbeit mit diesem Paneel haben können
double             ExtStep[];        // Schritte zum Ändern der Eigenschaften
int                ExtCount;         // Gesamtzahl der Eigenschaften
color              ExtColors[2];     // Array von Farben, um Zeilen anzuzeigen
string             ExtComments[2];   // Array von Kommentaren (für die Eigenschaft CHART_COMMENT)
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Kommentar auf dem Chart anzeigen
   Comment("SomeComment");
//--- Farben in das Array speichern, um später zwischen ihnen umzuschalten
   ExtColors[0]=InpFirstColor;
   ExtColors[1]=InpSecondColor;
//--- Kommentare in das Array speichern, um später zwischen ihnen umzuschalten
   ExtComments[0]="FirstComment";
   ExtComments[1]="SecondComment";
//--- Bedienfeld vorbereiten und anzeigen
   if(!PrepareControls())
      return(INIT_FAILED);
//--- erfolgreiche Ausführung
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Deinitialization function of the expert                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Den Text des Kommentars aus dem Chart löschen
   Comment("");
  }
//+------------------------------------------------------------------+
//| Chart Event Handler                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- Überprüfen das Ereignis von Klick auf das Objekt es Charts
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- Aufteilen den Namen des Objekts auf Abscheider
      string obj_name[];
      StringSplit(sparam,'_',obj_name);
      //--- Überprüfen ob das Objekt eine Taste ist
      if(obj_name[0]=="Button")
        {
         //--- Index der Taste erhalten
         int index=(int)StringToInteger(obj_name[1]);
         //--- Taste in nicht gedrückte Zustand setzen
         ExtButtons[index].State(false);
         //--- Den neuen Wert der Eigenschaft je nach ihr Typ setzen
         if(ExtDataTypes[index]=='I')
            ChangeIntegerProperty(index);
         if(ExtDataTypes[index]=='D')
            ChangeDoubleProperty(index);
         if(ExtDataTypes[index]=='S')
            ChangeStringProperty(index);
        }
     }
//--- Eigenschaftswerten neu zeichnen
   RedrawProperties();
   ChartRedraw();
;}
//+------------------------------------------------------------------+
//| Ändern die integrale Eigenschaft des Charts                      |
//+------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
  {
//--- Erhalten wir den aktuellen Wert der Eigenschaft
   long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index]);
//--- Definieren den folgenden Wert der Eigenschaft
   switch(ExtDrawTypes[index])
     {
      case 'C':
         value=GetNextColor((color)value);
         break;
      default:
         value=(long)GetNextValue((double)value,index);
         break;
     }
//--- Geben wir den aktuellen Wert der Eigenschaft ein
   ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index],0,value);
  }
//+------------------------------------------------------------------+
//| Ändern die echte Eigenschaft des Charts                          |
//+------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
  {
//--- Erhalten wir den aktuellen Wert der Eigenschaft
   double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index]);
//--- Definieren den folgenden Wert der Eigenschaft
   value=GetNextValue(value,index);
//--- Geben wir den aktuellen Wert der Eigenschaft ein
   ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index],value);
  }
//+------------------------------------------------------------------+
//| Ändern die String-Eigenschaft des Charts                         |
//+------------------------------------------------------------------+
void ChangeStringProperty(const int index)
  {
//--- Statische Variable um Kommentare ExtComments innerhalb des Arrays zu wechseln
   static uint comment_index=1;
//--- Ändern Index für einen weiteren Kommentar
   comment_index=1-comment_index;
//--- Geben wir den aktuellen Wert der Eigenschaft ein
   ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[index],ExtComments[comment_index]);
  }
//+------------------------------------------------------------------+
//| Identifizierung des nächsten Wertes der Eigenschaft              |
//+------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
  {
   if(value+ExtStep[index]<=ExtMaxValue[index])
      return(value+ExtStep[index]);
   else
      return(ExtMinValue[index]);
  }
//+------------------------------------------------------------------+
//| Erhalten die nächste Farbe für die Eigenschaft von Typ color     |
//+------------------------------------------------------------------+
color GetNextColor(const color clr)
  {
//--- Den nächsten Farbwert zurückgeben
   switch(clr)
     {
      case clrWhite: return(clrRed);
      case clrRed:   return(clrGreen);
      case clrGreen: return(clrBlue);
      case clrBlue:  return(clrBlack);
      default:       return(clrWhite);
    ;}
  }
//+------------------------------------------------------------------+
//| Eigenschaftswerten neu zeichnen                                  |
//+------------------------------------------------------------------+
void RedrawProperties(void)
  {
//--- Text des Eigenschaftswertes
   string text;
   long   value;
//--- Zyklus über die Anzahl der Eigenschaften
   for(int i=0;i<ExtCount;i++)
     {
      text="";
      switch(ExtDataTypes[i])
        {
         case 'I':
            //--- Erhalten wir den aktuellen Wert der Eigenschaft
            if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[i],0,value))
            break;
            //--- Text der Integer-Eigenschaft
            switch(ExtDrawTypes[i])
              {
               //--- Farbeigenschaft
               case 'C':
                  text=(string)((color)value);
                  break;
                  //--- Boolesche Eigenschaft
               case 'B':
                  text=(string)((bool)value);
                  break;
                  //--- Eigenschaft von ENUM_CHART_MODE
               case 'M':
                  text=EnumToString((ENUM_CHART_MODE)value);
                  break;
                  //--- Eigenschaft von ENUM_CHART_VOLUME_MODE
               case 'V':
                  text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
                  break;
                  //--- Nummer er Typ int
               default:
                  text=IntegerToString(value);
                  break;
              }
            break;
         case 'D':
            //--- Text der echten Eigenschaft
            text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[i]),4);
            break;
         case 'S':
            //--- Text der String-Eigenschaft
            text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[i]);
            break;
        }
      //--- Anzeige der Wert der Eigenschaft
      ExtLabelsValue[i].Description(text);
     }
  }
//+------------------------------------------------------------------+
//| Erstellung einer Platte,um die Eigenschaften des Charts          |
//| zu kontrollieren                                                 |
//+------------------------------------------------------------------+
bool PrepareControls(void)
  {
//--- Reservieren Speicher für Arrays mit Reserve
   MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- Variablen
   int i=0;     // Zyklus-Variable
   int col_1=0; // Anzahl der Eigenschaften in der erste Spalte
   int col_2=0; // Anzahl der Eigenschaften in der zweite Spalte
   int col_3=0; // Anzahl der Eigenschaften in der dritte Spalte
//--- Die aktuelle Anzahl von Eigenschaften ist 0
   ExtCount=0;
//--- Suche nach Eigenschaften in Zyklus
   while(i<=LAST_PROPERTY_NUMBER)
     {
      //--- Den aktuellen Nummer der Eigenschaft speichern
      ExtNumbers[ExtCount]=i;
      //--- Den Wert der Zyklus-Eigenschaft erhöhen
      i++;
      //--- Prüfen, ob es eine Eigenschaft mit diesem Nummer gibt
      if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
        {
         //--- Steuerelemente für Eigenschaften erstellen
         switch(ExtGroupTypes[ExtCount])
           {
            case 1:
               //--- ein Label und eine Schaltfläche für die Eigenschaft erstellen
               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);
               //--- Die Anzahl der Elemente in der ersten Spalte hat erhöht
               col_1++;
               break;
            case 2:
               //--- ein Label und eine Schaltfläche für die Eigenschaft erstellen
               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);
               //--- Die Anzahl der Elemente in der zweite Spalte hat erhöht
               col_2++;
               break;
            case 3:
               //--- Nur Label für Eigenschaften erstellen
               if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,false))
               return(false);
               //--- Die Anzahl der Elemente in der dritten Spalte hat erhöht
               col_3++;
               break;
           }
         //--- Den maximalen und minimalen Wert und den Schritt definieren
         GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
         //--- Erhöhung der Anzahl der Eigenschaften
         ExtCount++;
        }
     }
//--- Freien wir den Speicher, der durch Arrays nicht verwendet wird
   MemoryAllocation(ExtCount);
//--- Eigenschaftswerten neu zeichnen
   RedrawProperties();
   ChartRedraw();
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Speicher für Arrays reservieren                                  |
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Prüfen ob der Index der Eigenschaft zu einem der Enumerationen   |
//| ENUM_CHART_PROPERTIES gehört                                     |
//+------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
  {
//--- Prüfen, ob die Eigenschaft eine ganze Zahl ist
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind);
   if(_LastError==0)
     {
      data_type='I';                      // Eigenschaft aus ENUM_CHART_PROPERTY_INTEGER
      GetTypes(ind,group_type,draw_type); // Parameter von Anzeige der Eigenschaften definieren
      return(true);
     }
//--- Prüfen, ob die Eigenschaft echt ist
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind);
   if(_LastError==0)
     {
      data_type='D';                      // Eigenschaft aus Enumeration ENUM_CHART_PROPERTY_DOUBLE
      GetTypes(ind,group_type,draw_type); // Parameter von Anzeige der Eigenschaften definieren
      return(true);
     }
//--- Prüfen, ob die Eigenschaft String ist
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind);
   if(_LastError==0)
     {
      data_type='S';                      // Eigenschaft aus Enumeration ENUM_CHART_PROPERTY_STRING
      GetTypes(ind,group_type,draw_type); // Parameter von Anzeige der Eigenschaften definieren
      return(true);
     }
//--- die Eigenschaft gehört zu keiner Enumeration
   return(false);
  }
//+------------------------------------------------------------------+
//| Definieren, in welcher Gruppe die Eigenschaft sein sollte,       |
//| und ihr Display-Typ                                              |
//+------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- Prüfen, ob die Eigenschaft zur dritten Grippe gehört
//--- Eigenschaften der dritten Gruppe werden in der zweite Spalte von CHART_BRING_TO_TOP angezeigt
   if(CheckThirdGroup(property_number,group_type,draw_type))
      return;
//--- Prüfen, ob die Eigenschaft zur zweiten Grippe gehört
//--- Eigenschaften der zweiten Gruppe werden in der zweite Spalte von Anfang angezeigt
   if(CheckSecondGroup(property_number,group_type,draw_type))
      return;
//--- Wenn Sie hier sind, bedeutet es, das die Eigenschaft zur ersten Gruppe (erste Spalte) gehört
   CheckFirstGroup(property_number,group_type,draw_type);
  }
//+------------------------------------------------------------------+
//| Die Funktion überprüft, ob die Eigenschaft zur dritten Gruppe    |
//| gehört, und wenn ja, bestimmt den Display-Typ                    |
//+------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- Prüfen, ob die Eigenschaft zur dritten Grippe gehört
   switch(property_number)
     {
      //--- Boolesche Eigenschaften
      case CHART_IS_OBJECT:
      case CHART_WINDOW_IS_VISIBLE:
         draw_type='B';
         break;
         //--- Integer Eigenschaften
      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;
         //--- echte Eigenschaften
      case CHART_PRICE_MIN:
      case CHART_PRICE_MAX:
         draw_type='D';
         break;
         //--- In der Tat ist diese Eigenschaft eine Instruktion den Chat an der Spitze aller anderen anzuzeigen
         //--- Für dieses Panel ist ihre Anwendung nicht notwendig, da das Fenster ist immer
         //--- über alle anderen Fenster
      case CHART_BRING_TO_TOP:
         draw_type=' ';
         break;
         //--- Die Eigenschaft gehört nicht zur dritten Gruppe
      default:
         return(false);
     }
//--- Die Eigenschaft gehört zur dritten Gruppe
   group_type=3;
   return(true);
  }
//+------------------------------------------------------------------+
//| Die Funktion überprüft, ob die Eigenschaft zur zweiten Gruppe    |
//| gehört, und wenn ja, bestimmt den Display-Typ                    |
//+------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- Prüfen, ob die Eigenschaft zur zweiten Grippe gehört
   switch(property_number)
     {
      //--- Eigenschaft von Typ ENUM_CHART_MODE
      case CHART_MODE:
         draw_type='M';
         break;
         //--- Eigenschaft von Typ ENUM_CHART_VOLUME_MODE
      case CHART_SHOW_VOLUMES:
         draw_type='V';
         break;
         //--- String-Eigenschaft
      case CHART_COMMENT:
         draw_type='S';
         break;
         //--- Eigenschaft der Farbe
      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;
         //--- Die Eigenschaft gehört nicht zur zweiten Gruppe
      default:
         return(false);
     }
//--- Die Eigenschaft gehört zur zweiten Gruppe
   group_type=2;
   return(true);
  }
//+------------------------------------------------------------------+
//| Diese Funktion wird nur aufgerufen, wenn es bereits bekannt ist, |
//| dass die Eigenschaft nicht zur zweiten und dritten Gruppe        |
//| von Eigenschaften gehört                                         |
//+------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- Die Eigenschaft gehört zur ersten Gruppe
   group_type=1;
//--- Typ von Anzeige der Eigenschaft definieren
   switch(property_number)
     {
      //--- Integer Eigenschaften
      case CHART_SCALE:
      case CHART_HEIGHT_IN_PIXELS:
         draw_type='I';
         return;
         //--- echte Eigenschaften
      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;
         //--- Nur Boolesche Eigenschaften
      default:
         draw_type='B';
         return;
     }
  }
//+------------------------------------------------------------------+
//| Ein Label und eine Schaltfläche für die Eigenschaft erstellen    |
//+------------------------------------------------------------------+
bool ShowProperty(const int ind,const int type,const int x1,const int x2,
                  const int xb,const int y,const bool btn)
  {
//--- Statischer Array um innerhalb des Farbe-Arrays ExtColors zu wechseln
   static uint color_index[3]={1,1,1};
//--- Ändern Index für eine andere Farbe
   color_index[type]=1-color_index[type];
//--- Label und Taste (wenn btn=true) für die Eigenschaft anzeigen
   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);
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Label erstellen                                                  |
//+------------------------------------------------------------------+
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);
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Taste erstellen                                                  |
//+------------------------------------------------------------------+
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);
//--- erfolgreiche Ausführung
   return(true);
  }
//+------------------------------------------------------------------+
//| Den maximalen und minimalen Wert und den Schritt eingeben        |
//+------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
  {
   double value;
//--- Den neuen Wert der Eigenschaft je nach ihr Typ setzen
   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;
         //--- Default values
      default:
         max=1;
         min=0;
         step=1;
     }
  }

Darstellung des Charts

Objektkonstanten