Exemples d'Utilisation du Graphique

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si un objet est un graphique. Si c'est un objet graphique,                                 |
//| le résultat vaut true. Si c'est un graphique réel, la variable résultat                            |
//| a la valeur false.                                                                                 |
//+----------------------------------------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la propriété du graphique
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      //--- retourne false
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }

//+------------------------------------------------------------------------------------------------+
//| Envoie une commande au terminal pour afficher le graphique par-dessus tous les autres          |
//+------------------------------------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- affiche le graphique par-dessus tous les autres
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------+
//| Vérifie si le défilement du graphique avec le bouton gauche de la souris est activé    |
//+----------------------------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Active/désactive le défilement du graphique avec le bouton gauche de la souris |
//+--------------------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si les messages des évènements de déplacement et de clics de souris                        |
//| sont envoyés à toutes les applications MQL5 du graphique                                           |
//+----------------------------------------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+------------------------------------------------------------------------------------------------+
//| Active/désactive le mode d'envoi des messages concernant les évènements des mouvements et      |
//| de clics de souris à toutes les applications MQL5 sur le graphique                             |
//+------------------------------------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------+
//| Vérfie si les messages concernant l'évènement de création d'un objet  |
//| graphique sont envoyés aux applications MQL5 sur le graphique         |
//+-----------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------+
//| Active/désactive le mode d'envoi des messages concernant les évènements de création    |
//| d'un objet graphique aux applications mql5 sur le graphique                            |
//+----------------------------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------+
//| Vérifie si les messages concernant l'évènement de suppression d'un    |
//| objet graphique sont envoyés aux applications mql5 sur le graphique   |
//+-----------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------+
//| Active/désactive le mode d'envoi des messages concernant les évènements de suppression |
//| d'un objet graphique aux applications mql5 sur le graphique                            |
//+----------------------------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère le type d'affichage du graphique (chandeliers, bougies ou ligne brisée)                   |
//+----------------------------------------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=WRONG_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((ENUM_CHART_MODE)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit le type d'affichage du graphique (chandeliers, bougies ou ligne brisée)                    |
//+----------------------------------------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si le graphique des prix est affiché au premier plan                                       |
//+----------------------------------------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage du graphique des prix au premier plan                                 |
//+----------------------------------------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------+
//| Vérifie si le décalage du graphique des prix du bord droit est activé |
//+-----------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+---------------------------------------------------------------------------------+
//| Active/désactive le décalage du graphique des prix du bord droit                |
//+---------------------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si le défilement automatique du graphique vers la droite à l'arrivée                       |
//| des nouveaux ticks est activé                                                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive le défilement automatique du graphique vers la droite à l'arrivée                 |
//| à l'arrivée des nouveaux ticks                                                                     |
//+----------------------------------------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère l'échelle du graphique (de 0 à 5)                                                         |
//+----------------------------------------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit l'échelle du graphique (de 0 à 5)                                                          |
//+----------------------------------------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si le mode d'échelle fixe est activé                                                       |
//+----------------------------------------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive le mode d'échelle fixe                                                            |
//+----------------------------------------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si l'échelle "1:1" est activée                                                             |
//+----------------------------------------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive le mode d'échelle "1:1"                                                           |
//+----------------------------------------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si le mode d'échelle "points par barre" est activé                                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive le mode d'échelle "points par barre"                                              |
//+----------------------------------------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------------------------------+
//| Vérifie si l'affichage des valeurs OHLC dans le coin supérieur gauche du graphique est activé |
//+-----------------------------------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage des valeurs OHLC dans le coin supérieur gauche du graphique       |
//+------------------------------------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si l'affichage du prix Bid sous forme d'une ligne horizontale est activé                   |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de la ligne Bid sur le graphique                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si l'affichage du prix Ask sous forme d'une ligne horizontale est activé                   |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de la ligne Ask sur le graphique                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------------------------------------+
//| Vérifie si l'affichage du prix Last sous forme d'une ligne horizontale est activé                   |
//+-----------------------------------------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+--------------------------------------------------------------------------------------+
//| Active/désactive l'affichage d'une ligne au prix de la dernière transaction effectué |
//+--------------------------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+---------------------------------------------------------------------------------+
//| Vérifie si l'affichage de séparateurs verticaux entre les périodes est activé   |
//+---------------------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+-----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de séparateurs verticaux entre les périodes adjacentes                 |
//+-----------------------------------------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si la grille est affichée sur le graphique                                                 |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de la grille sur le graphique                                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si les volumes sont affichés sur le graphique.                                             |
//| Le flag indique le mode d'affichage des volumes                                                    |
//+----------------------------------------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=WRONG_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit le mode d'affichage des volumes sur le graphique                                           |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------+
//| Vérifie si les descriptions des objets graphiques s'affichent lorsque |
//| la souris passe au-dessus d'eux                                       |
//+-----------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+--------------------------------------------------------------------------------------+
//| Active/désactive l'affichage des descriptions des objets graphiques lorsque          |
//| la souris passe au-dessus d'eux                                                      |
//+--------------------------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+------------------------------------------------------------------------------------------------+
//| Récupère le nombre de barres qui sont affichées (visibles) sur le graphique                    |
//+------------------------------------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+--------------------------------------------------------------------------------------------+
//| Récupère le nombre total de fenêtres graphiques incluant les sous-fenêtres des indicateurs |
//+--------------------------------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si la fenêtre actuelle du graphique ou la sous-fenêtre est visible                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère le handle du graphique                                                                    |
//+----------------------------------------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la distance en pixels entre la bordure supérieure de la sous-fenêtre et                   |
//| la bordure supérieure de la fenêtre principale du graphique                                        |
//+----------------------------------------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+------------------------------------------------------------------------------------------------+
//| Récupère l'index de la première barre visible sur le graphique.                                |
//| L'indexation est comme pour les timeseries : les dernières barres ont les plus petits indices. |
//+------------------------------------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la largueur du graphique (en barres)                                                      |
//+----------------------------------------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la largeur du graphique (en pixels)                                                       |
//+----------------------------------------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la hauteur du graphique (en pixels)                                                       |
//+----------------------------------------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long result=-1;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((int)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la hauteur du graphique (en pixels)                                                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur d'arrière plan d'un graphique                                                  |
//+----------------------------------------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur d'arrière plan du graphique
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur d'arrière plan du graphique                                                     |
//+----------------------------------------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur d'arrière plan du graphique
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur des axes, de l'échelle et de la ligne OHLC                                     |
//+----------------------------------------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur des axes, de l'échelle et de la ligne OHLC
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur des axes, de l'échelle et de la ligne OHLC                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur des axes, de l'échelle et de la ligne OHLC
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur de la grille du graphique                                                      |
//+----------------------------------------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur de la grille du graphique
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur de la grille du graphique                                                       |
//+----------------------------------------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur de la grille du graphique
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur des volumes et des niveaux d'entrée sur le marché                              |
//+----------------------------------------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur des volumes et des niveaux d'entrée sur le marché
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur des volumes et des niveaux d'entrée sur le marché                               |
//+----------------------------------------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur des volumes et des niveaux d'entrée sur le marché
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------------------------------------+
//| Récupère la couleur d'une barre haussière, de l'ombre et du contour du corps d'une bougie haussière |
//+-----------------------------------------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur d'une barre haussière, de l'ombre et du contour du corps d'une bougie haussière
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur d'une barre haussière, de l'ombre et du contour du corps d'une bougie haussière |
//+----------------------------------------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur d'une barre haussière, de l'ombre et du contour du corps d'une bougie haussière
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-----------------------------------------------------------------------------------------------------+
//| Récupère la couleur d'une barre baissière, de l'ombre et du contour du corps d'une bougie baissière |
//+-----------------------------------------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur d'une barre baissière, de l'ombre et du contour du corps d'une bougie baissière
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+-----------------------------------------------------------------------------------------------------+
//| Définit la couleur d'une barre baissière, de l'ombre et du contour du corps d'une bougie baissière  |
//+-----------------------------------------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur d'une barre baissière, de l'ombre et du contour du corps d'une bougie baissière
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur de la ligne du graphique et des bougies en forme de Doji                       |
//+----------------------------------------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur de la ligne du graphique et des bougies en forme de Doji
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur de la ligne du graphique et des bougies en forme de Doji                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur de la ligne du graphique et des bougies en forme de Doji
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur du corps des chandeliers haussiers                                             |
//+----------------------------------------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur du corps des chandeliers haussiers
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur du corps des chandeliers haussiers                                              |
//+----------------------------------------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur du corps des chandeliers haussiers
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur du corps des chandeliers baissiers                                             |
//+----------------------------------------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur du corps des chandeliers baissiers
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur du corps des chandeliers baissiers                                              |
//+----------------------------------------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur du corps des chandeliers baissiers
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur de la ligne du prix Bid                                                        |
//+----------------------------------------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur de la ligne du prix Bid
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur de la ligne du prix Bid                                                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur de la ligne du prix Bid
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur de la ligne du prix Ask                                                        |
//+----------------------------------------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur de la ligne du prix Ask
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur de la ligne du prix Ask                                                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur de la ligne du prix Ask
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur de la ligne du prix de la dernière transaction effectuée                       |
//+----------------------------------------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur de la ligne du prix de la dernière transaction effectuée (Last)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur de la ligne du prix de la dernière transaction effectuée                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur de la ligne du prix de la dernière transaction effectuée (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la couleur des niveaux des Stop Loss et Take Profit                                       |
//+----------------------------------------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- prépare la variable pour recevoir la couleur
   long result=clrNONE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- récupère la couleur des niveaux des ordres stop (Stop Loss et Take Profit)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return((color)result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la couleur des niveaux des Stop Loss et Take Profit                                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la couleur des niveaux des ordres stop (Stop Loss et Take Profit)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie les niveaux de trading sont affichés sur le graphique                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage des niveaux de trading                                                |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+------------------------------------------------------------------------------------------------+
//| Vérifie si le glissement des niveaux de trading avec la souris est autorisé                    |
//+------------------------------------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive le glissement des niveaux de trading sur le graphique en utilisant la souris      |
//+----------------------------------------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si l'échelle du temps est affichée sur le graphique                                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de l'échelle du temps sur le graphique                                |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si l'échelle des prix est affichée sur le graphique                                        |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage de l'échelle des prix sur le graphique                                |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Vérifie si le panneau de "Trading En Un Clic" est affiché sur le graphique                         |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique en mémoire
   result=value;
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Active/désactive l'affichage du panneau de "Trading En Un Clic"                                    |
//| sur le graphique                                                                                   |
//+----------------------------------------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+-------------------------------------------------------------------------+
//| Récupère la taille du décalage de la barre zéro depuis le bord droit    |
//| du graphique en pourcentage (de 10% à 50%)                              |
//+-------------------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }
//+-----------------------------------------------------------------------------------------------------+
//| Récupère la taille du décalage de la barre zéro depuis le bord droit |
//| du graphique en pourcentage (de 10% à 50%). |
//| Pour activer le décalage, la propriété CHART_SHIFT doit être à true. |
//+-----------------------------------------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+---------------------------------------------------------------------------------------------------+
//| Récupère la localisation de la position fixée du graphique depuis le bord gauche (en pourcentage) |
//+---------------------------------------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }
//+---------------------------------------------------------------------------------------------------------+
//| Récupère la localisation de la position fixée du graphique depuis le bord gauche (en pourcentage)       |
//| Pour voir la localisation de la position fixée du graphique, la valeur de la propriété CHART_AUTOSCROLL |
//| doit être à false.                                                                                      |
//+---------------------------------------------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la valeur du maximum fixé du graphique                                                    |
//+----------------------------------------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la valeur du maximum fixé du graphique.                                                    |
//| Pour changer la valeur de la propriété, la propriété CHART_SCALEFIX                                |
//| doit être à true.                                                                                  |
//+----------------------------------------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la valeur du minimum fixé du graphique                                                    |
//+----------------------------------------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }
//+----------------------------------------------------------------------------------------------------+
//| Définit la valeur du minimum fixé du graphique.                                                    |
//| Pour changer la valeur de la propriété, la propriété CHART_SCALEFIX                                |
//| doit être à true.                                                                                  |
//+----------------------------------------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+----------------------------------------------------------------------------------------------------+
//| Récupère la valeur de l'échelle du graphique en points par barre                                   |
//+----------------------------------------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }
//+------------------------------------------------------------------------------------------------+
//| Définit la valeur de l'échelle du graphique en points par barre                                |
//| Pour voir le résultat du changement de valeur de cette propriété, la valeur                    |
//| la propriété CHART_SCALE_PT_PER_BAR doit être à true.                                          |
//+------------------------------------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+------------------------------------------------------------------------------------------------+
//| Récupère la valeur du minimum du graphique dans la fenêtre principale ou dans une sous-fenêtre |
//+------------------------------------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }

//+------------------------------------------------------------------------------------------------+
//| Récupère la valeur du maximum du graphique dans la fenêtre principale ou dans une sous-fenêtre |
//+------------------------------------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- prépare la variable pour récupérer le résultat
   double result=EMPTY_VALUE;
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
     }
//--- retourne la valeur de la propriété du graphique
   return(result);
  }

//+----------------------------------------------------------------------------------------------------+
//| Retourne le commentaire du coin supérieur gauche du graphique                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- reçoit la valeur de la propriété
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }
//+----------------------------------------------------------------------------------------------------+
//| Retourne le commentaire du coin supérieur gauche du graphique                                      |
//+----------------------------------------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- réinitialise la valeur d'erreur
   ResetLastError();
//--- définit la valeur de la propriété
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- affiche le message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- exécution réussie
   return(true);
  }

//+------------------------------------------------------------------+
//| Détermine si la fenêtre actuelle du graphique est maximisée      |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur de l'erreur
   ResetLastError();
//--- récupère la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- affiche un message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique dans la variable
   result=value;
//--- exécution réussie
   return(true);
  }
  

//+------------------------------------------------------------------+
//| Détermine si la fenêtre actuelle du graphique est minimisée      |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- prépare la variable pour récupérer la valeur de la propriété
   long value;
//--- réinitialise la valeur de l'erreur
   ResetLastError();
//--- récupère la valeur de la propriété
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- affiche un message d'erreur dans le journal des Experts
      Print(__FUNCTION__+", Code d'Erreur = ",GetLastError());
      return(false);
     }
//--- stocke la valeur de la propriété du graphique dans la variable
   result=value;
//--- exécution réussie
   return(true);
  }