Справочник MQL5Константы, перечисления и структурыКонстанты графиковПримеры работы с графиком

Примеры работы с графиком

В этом разделе представлены примеры для работы со свойствами графика. Для каждого свойства приведены одна или две законченные функции, которые позволяют задавать/получать значение этого свойства. Эти функции можно использовать в своих MQL5 программах как есть.

На рисунке показана графическая панель для наглядной демонстрации того, как изменение свойства графика меняет его внешний вид. Нажатие кнопки "Next" позволяет установить новое значение соответствующего свойства и увидеть изменения в окне графика.

chart_properties_panel

Исходный код панели находится ниже.

Свойства графика и примеры функций для работы с ними

CHART_IS_OBJECT – определяет, является ли объект настоящим графиком или графическим объектом.

//+------------------------------------------------------------------+
//| Определение того, является ли объект графиком. Если это          |
//| графический объект, то результат true. Если же это настоящий     |
//| график, то переменная result примет значение false.              |
//+------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим свойство графика
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      //--- вернем false
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }

CHART_BRING_TO_TOP – показывает график поверх всех других.

//+------------------------------------------------------------------+
//| Отправка терминалу команды на показ графика поверх всех других.  |
//+------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- покажем график поверх всех других
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_MOUSE_SCROLL – свойство прокрутки графика левой кнопкой мыши.

//+------------------------------------------------------------------+
//| Функция определяет, можно ли прокручивать график левой кнопкой   |
//| мыши.                                                            |
//+------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим прокрутки графика левой кнопкой |
//| мыши.                                                            |
//+------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_EVENT_MOUSE_MOVE – свойство отправки mql5-программам сообщений о событиях перемещения и нажатия кнопок мыши (CHARTEVENT_MOUSE_MOVE).

//+------------------------------------------------------------------+
//| Отправляются ли сообщения о событиях перемещения и нажатия кнопок|
//| мыши всем mql5-программам на данном графике?                     |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отправки сообщений о событиях   |
//| перемещения и нажатия кнопок мыши всем mql5-программам на данном |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_EVENT_OBJECT_CREATE – свойство отправки mql5-программам сообщений о событии создания графического объекта (CHARTEVENT_OBJECT_CREATE).

//+------------------------------------------------------------------+
//| Отправляются ли сообщения о событии создания графического объекта|
//| всем mql5-программам на данном графике?                          |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отправки сообщений о событии    |
//| создания графического объекта всем mql5-программам на данном     |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_EVENT_OBJECT_DELETE – свойство отправки mql5-программам сообщений о событии удаления графического объекта (CHARTEVENT_OBJECT_DELETE).

//+------------------------------------------------------------------+
//| Отправляются ли сообщения о событии удаления графического объекта|
//| всем mql5-программам на данном графике?                          |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отправки сообщений о событии    |
//| удаления графического объекта всем mql5-программам на данном     |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_MODE – тип графика (свечи, бары или линия).

//+------------------------------------------------------------------+
//| Получение типа отображения графика (в виде свечей, баров или     |
//| линии).                                                          |
//+------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=WRONG_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((ENUM_CHART_MODE)result);
  }
//+------------------------------------------------------------------+
//| Установка типа отображения графика (в виде свечей, баров или     |
//| линии).                                                          |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_FOREGROUND – свойство отображения ценового графика на переднем плане.

//+------------------------------------------------------------------+
//| Функция определяет, отображается ли ценовой график на переднем   |
//| плане.                                                           |
//+------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения ценового графика на |
//| переднем плане.                                                  |
//+------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHIFT – режим отступа ценового графика от правого края.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения ценового графика|
//| с отступом от правого края.                                      |
//+------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения ценового графика с  |
//| отступом от правого края.                                        |
//+------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_AUTOSCROLL – режим автоматического перехода к правому краю графика.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим автоматической прокрутки    |
//| графика вправо при поступлении новых тиков.                      |
//+------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим автоматической прокрутки графика|
//| вправо при поступлении новых тиков.                              |
//+------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SCALE – свойство масштаба графика.

//+------------------------------------------------------------------+
//| Получение масштаба графика (от 0 до 5).                          |
//+------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Установка масштаба графика (от 0 до 5).                          |
//+------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SCALEFIX – режим фиксированного масштаба графика.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим фиксированного масштаба.    |
//+------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим фиксированного масштаба.        |
//+------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SCALEFIX_11 – режим масштаба графика 1:1.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим масштаба "1:1".             |
//+------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим масштаба "1:1"                  |
//+------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SCALE_PT_PER_BAR – режим указания масштаба графика в пунктах на бар.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим указания масштаба в пунктах |
//| на бар.                                                          |
//+------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим указания масштаба в пунктах на  |
//| бар.                                                             |
//+------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_OHLC – свойство отображения в левом верхнем углу значений OHLC.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения значений OHLC   |
//| в левом верхнем углу.                                            |
//+------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения значений OHLC в     |
//| левом верхнем углу графика.                                      |
//+------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_BID_LINE – свойство отображения значения Bid горизонтальной линией на графике.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения линии Bid на    |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения линии Bid на        |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_ASK_LINE – свойство отображения значения Ask горизонтальной линией на графике.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения линии Ask на    |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения линии Ask на        |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_LAST_LINE – свойство отображения значения Last горизонтальной линией на графике.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения линии для цены  |
//| последней совершенной сделки.                                    |
//+------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения линии цены последней|
//| совершенной сделки.                                              |
//+------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_PERIOD_SEP – свойство отображения вертикальных разделителей между соседними периодами.

//+------------------------------------------------------------------+
//| Функция определяет, включен ли режим отображения вертикальных    |
//| разделителей между соседними периодами.                          |
//+------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения вертикальных        |
//| разделителей между соседними периодами.                          |
//+------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_GRID – свойство отображения сетки на графике.

//+------------------------------------------------------------------+
//| Функция определяет, отображается ли сетка на графике.            |
//+------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает отображение сетки на графике.         |
//+------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_VOLUMES – свойство отображения объемов на графике.

//+------------------------------------------------------------------+
//| Функция определяет, отображаются ли объемы на графике (не        |
//| отображаются, отображаются тиковые, отображаются реальные).      |
//+------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=WRONG_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает режим отображения объемов на графике.      |
//+------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_OBJECT_DESCR – свойство всплывающих описаний графических объектов.

//+------------------------------------------------------------------+
//| Функция определяет, отображаются ли всплывающие описания         |
//| графических объектов при наведение на них мышью.                 |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения всплывающих описаний|
//| графических объектов при наведение на них мышью.                 |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_VISIBLE_BARS – определяет количество баров на графике, доступных для отображения.

//+------------------------------------------------------------------+
//| Функция получает количество баров, которые отображаются (видимы )|
//| в окне графика.                                                  |
//+------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_WINDOWS_TOTAL – определяет общее количество окон графика, включая подокна индикаторов.

//+------------------------------------------------------------------+
//| Функция получает общее количество окон графика, включая подокна  |
//| индикаторов.                                                     |
//+------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_WINDOW_IS_VISIBLE – определяет видимость подокна.

//+------------------------------------------------------------------+
//| Функция определяет, является ли данное окно или подокно графика  |
//| видимым.                                                         |
//+------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }

CHART_WINDOW_HANDLE – возвращает хэндл графика.

//+------------------------------------------------------------------+
//| Функция получает хэндл графика                                   |
//+------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_WINDOW_YDISTANCE – определяет дистанцию в пикселях между верхней рамкой подокна индикатора и верхней рамкой главного окна графика.

//+------------------------------------------------------------------+
//| Функция получает расстояние в пикселях между верхней рамкой      |
//| подокна и верхней рамкой главного окна графика.                  |
//+------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_FIRST_VISIBLE_BAR – возвращает номер первого видимого бара на графике (индексация баров соответствует таймсерии).

//+------------------------------------------------------------------+
//| Функция получает номер первого видимого бара на графике.         |
//| Индексация как в таймсерии, последние бары имеют меньшие индексы.|
//+------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_WIDTH_IN_BARS – возвращает ширину графика в барах.

//+------------------------------------------------------------------+
//| Функция получает значение ширины графика в барах.                |
//+------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_WIDTH_IN_PIXELS – возвращает ширину графика в пикселях.

//+------------------------------------------------------------------+
//| Функция получает значение ширины графика в пикселях.             |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }

CHART_HEIGHT_IN_PIXELS – свойство высоты графика в пикселях.

//+------------------------------------------------------------------+
//| Функция получает значение высоты графика в пикселях.             |
//+------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- подготовим переменную для получения значения свойства
   long result=-1;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает значение высоты графика в пикселях.        |
//+------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_BACKGROUND – цвет фона графика.

//+------------------------------------------------------------------+
//| Функция получает цвет фона графика.                              |
//+------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет фона графика
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет фона графика.                         |
//+------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет фона графика
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_FOREGROUND – цвет осей, шкалы и строки OHLC.

//+------------------------------------------------------------------+
//| Функция получает цвет осей, шкалы и строки OHLC графика.         |
//+------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет осей, шкалы и строки OHLC графика
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет осей, шкалы и строки OHLC графика.    |
//+------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет осей, шкалы и строки OHLC графика
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_GRID – цвет сетки графика.

//+------------------------------------------------------------------+
//| Функция получает цвет сетки графика.                             |
//+------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет сетки графика
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет сетки графика.                        |
//+------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет сетки графика
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_VOLUME – цвет объемов и уровней открытия позиций.

//+------------------------------------------------------------------+
//| Функция получает цвет отображения объемов и уровней открытия     |
//| позиций.                                                         |
//+------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет объемов и уровней открытия позиций
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет отображения объемов и уровней открытия|
//| позиций.                                                         |
//+------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет объемов и уровней открытия позиций
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_CHART_UP – цвет бара вверх, тени и окантовки тела бычьей свечи.

//+------------------------------------------------------------------+
//| Функция получает цвет бара направленного вверх, цвет тени и      |
//| окантовки тела бычьей свечи.                                     |
//+------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет бара вверх, тени и окантовки тела бычьей свечи
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет бара направленного вверх, цвет тени и |
//| окантовки тела бычьей свечи.                                     |
//+------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет бара вверх, тени и окантовки тела бычьей свечи
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_CHART_DOWN – цвет бара вниз, тени и окантовки тела медвежьей свечи.

//+------------------------------------------------------------------+
//| Функция получает цвет бара направленного вниз, цвет тени и       |
//| окантовки тела медвежьей свечи.                                  |
//+------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет бара вниз, тени и окантовки тела медвежьей свечи
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет бара направленного вниз, цвет тени и  |
//| окантовки тела медвежьей свечи.                                  |
//+------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет бара вниз, тени и окантовки тела медвежьей свечи
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_CHART_LINE – цвет линии графика и японских свечей "Доджи".

//+------------------------------------------------------------------+
//| Функция получает цвет линии графика и японских свечей "Доджи".   |
//+------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет линии графика и японских свечей "Доджи"
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет линии графика и японских свечей       |
//| "Доджи".                                                         |
//+------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет линии графика и японских свечей "Доджи"
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_CANDLE_BULL – цвет тела бычьей свечи.

//+------------------------------------------------------------------+
//| Функция получает цвет тела бычьей свечи.                         |
//+------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет тела бычьей свечи
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет тела бычьей свечи.                    |
//+------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет тела бычьей свечи
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_CANDLE_BEAR – цвет тела медвежьей свечи.

//+------------------------------------------------------------------+
//| Функция получает цвет тела медвежьей свечи.                      |
//+------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет тела медвежьей свечи
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет тела медвежьей свечи.                 |
//+------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет тела медвежьей свечи
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_BID – цвет линии цены Bid.

//+------------------------------------------------------------------+
//| Функция получает цвет отображения линии Bid.                     |
//+------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет линии цены Bid
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет отображения линии Bid.                |
//+------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет линии цены Bid
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_ASK – цвет линии цены Ask.

//+------------------------------------------------------------------+
//| Функция получает цвет отображения линии Ask.                     |
//+------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет линии цены Ask
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет отображения линии Ask.                |
//+------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет линии цены Ask
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_LAST – цвет линии цены последней совершенной сделки (Last).

//+------------------------------------------------------------------+
//| Функция получает цвет линии цены последней совершенной сделки.   |
//+------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет линии цены последней совершенной сделки (Last)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвет линии цены последней совершенной      |
//| сделки.                                                          |
//+------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет линии цены последней совершенной сделки (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_COLOR_STOP_LEVEL – цвет уровней стоп-ордеров (Stop Loss и Take Profit).

//+------------------------------------------------------------------+
//| Функция получает цвета уровней Stop Loss и Take Profit.          |
//+------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения цвета
   long result=clrNONE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим цвет уровней стоп-ордеров (Stop Loss и Take Profit)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return((color)result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает цвета уровней Stop Loss и Take Profit.     |
//+------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим цвет уровней стоп-ордеров (Stop Loss и Take Profit)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_TRADE_LEVELS – свойство отображения на графике торговых уровней (уровни открытых позиций, Stop Loss, Take Profit и отложенных ордеров).

//+------------------------------------------------------------------+
//| Функция определяет, отображаются ли на графике торговые уровни.  |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения торговых уровней.   |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_DRAG_TRADE_LEVELS – свойство разрешения на перетаскивание торговых уровней на графике с помощью мышки.

//+------------------------------------------------------------------+
//| Функция определяет, можно ли перетаскивать торговые уровни на    |
//| графике при помощи мыши.                                         |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим перетаскивание торговых уровней |
//| на графике при помощи мыши.                                      |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_DATE_SCALE – свойство отображения на графике шкалы времени.

//+------------------------------------------------------------------+
//| Функция определяет, отображается ли на графике шкала времени.    |
//+------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения шкалы времени на    |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_PRICE_SCALE – свойство отображения на графике шкалы цены.

//+------------------------------------------------------------------+
//| Функция определяет, отображается ли на графике шкала цены.       |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения шкалы цены на       |
//| графике.                                                         |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHOW_ONE_CLICK – отображение на графике панели быстрой торговли (опция "Торговля одним кликом").

//+------------------------------------------------------------------+
//| Функция определяет, отображается ли на графике                   |
//| панель быстрой торговли ("Торговля одним кликом")                |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция включает/выключает режим отображения                     |
//| панели быстрой торговли на графике                               |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_SHIFT_SIZE – размер отступа нулевого бара от правого края в процентах.

//+------------------------------------------------------------------+
//| Функция получает размер отступа нулевого бара от правого края    |
//| графика в процентах (от 10% до 50%).                             |
//+------------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает размер отступа нулевого бара от правого    |
//| края графика в процентах (от 10% до 50%). Для включения режима   |
//| отступа, нужно установить значение свойства CHART_SHIFT равным   |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_FIXED_POSITION – положение фиксированной позиции графика от левого края в процентах.

//+------------------------------------------------------------------+
//| Функция получает положение фиксированной позиции графика от      |
//| левого края в процентах.                                         |
//+------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает положение фиксированной позиции графика от |
//| левого края в процентах. Для того  чтобы увидеть положение       |
//| фиксированной позиции на графике, нужно предварительно задать    |
//| значение свойства CHART_AUTOSCROLL равным false.                 |
//+------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_FIXED_MAX – свойство фиксированного максимума графика.

//+------------------------------------------------------------------+
//| Функция получает значение фиксированного максимума графика.      |
//+------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает значение фиксированного максимума графика. |
//| Для того чтобы удалось изменить значение этого свойства, нужно   |
//| предварительно задать значение свойства CHART_SCALEFIX равным    |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_FIXED_MIN – свойство фиксированного минимума графика.

//+------------------------------------------------------------------+
//| Функция получает значение фиксированного минимума графика.       |
//+------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает значение фиксированного минимума графика.  |
//| Для того чтобы удалось изменить значение этого свойства, нужно   |
//| предварительно задать значение свойства CHART_SCALEFIX равным    |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_POINTS_PER_BAR – значение масштаба в пунктах на бар.

//+------------------------------------------------------------------+
//| Функция получает значение масштаба графика в пунктах на бар.     |
//+------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает значение масштаба графика в пунктах на бар.|
//| Для того чтобы посмотреть результат изменения значения этого     |
//| свойства, нужно предварительно задать значение свойства          |
//| CHART_SCALE_PT_PER_BAR равным true.                              |
//+------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_PRICE_MIN – возвращает значение минимума графика.

//+------------------------------------------------------------------+
//| Функция получает значение минимума графика в главном окне или    |
//| подокне.                                                         |
//+------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }

CHART_PRICE_MAX – возвращает значение максимума графика.

//+------------------------------------------------------------------+
//| Функция получает значение максимума графика в главном окне или   |
//| подокне.                                                         |
//+------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- подготовим переменную для получения результата
   double result=EMPTY_VALUE;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- вернем значение свойства графика
   return(result);
  }

CHART_COMMENT – текст комментария на графике.

//+------------------------------------------------------------------+
//| Функция получает текст комментария в левом верхнем углу графика. |
//+------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция устанавливает текст комментария в левом верхнем углу     |
//| графика.                                                         |
//+------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- сбросим значение ошибки
   ResetLastError();
//--- установим значение свойства
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- успешное выполнение
   return(true);
  }

CHART_IS_MAXIMIZED – окно графика развернуто

//+------------------------------------------------------------------+
//| Функция определяет, является ли данное окно графика развернутым  |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }

CHART_IS_MINIMIZED – окно графика свернуто

//+------------------------------------------------------------------+
//| Функция определяет, является ли данное окно графика свернутым    |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- подготовим переменную для получения значения свойства
   long value;
//--- сбросим значение ошибки
   ResetLastError();
//--- получим значение свойства
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- выведем сообщение об ошибке в журнал "Эксперты"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- запомним в переменную значение свойства графика
   result=value;
//--- успешное выполнение
   return(true);
  }

Панель для свойств графика

//--- подключим библиотеку элементов управления
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- предопределенные константы
#define X_PROPERTY_NAME_1    10  // х-координата имени свойства в первом столбце
#define X_PROPERTY_VALUE_1   225 // x-координата значения свойства в первом столбце
#define X_PROPERTY_NAME_2    345 // x-координата имени свойства во втором и третьем столбцах
#define X_PROPERTY_VALUE_2   550 // x-координата значения свойства во втором и третьем столбце
#define X_BUTTON_1           285 // x-координата кнопки в первом столбце
#define X_BUTTON_2           700 // x-координата кнопки во втором столбце
#define Y_PROPERTY_1         30  // y-координата начала первого и второго столбца
#define Y_PROPERTY_2         286 // y-координата начала третьего столбца
#define Y_DISTANCE           16  // расстояние по оси y между строками
#define LAST_PROPERTY_NUMBER 111 // номер последнего графического свойства
//--- входные параметры
input color InpFirstColor=clrDodgerBlue; // Цвет нечетных строк
input color InpSecondColor=clrGoldenrod; // Цвет четных строк
//--- переменные и массивы
CChartObjectLabel  ExtLabelsName[];  // надписи для отображения имен свойств
CChartObjectLabel  ExtLabelsValue[]; // надписи для отображения значений свойств
CChartObjectButton ExtButtons[];     // кнопки
int                ExtNumbers[];     // индексы свойств
string             ExtNames[];       // имена свойств
uchar              ExtDataTypes[];   // типы данных свойств (integer, double, string)
uint               ExtGroupTypes[];  // массив, который хранит данные о принадлежности свойств к одной из групп
uchar              ExtDrawTypes[];   // массив, который хранит данные о способе отображения свойств
double             ExtMaxValue[];    // максимальные значения свойств, которые они могут принимать в процессе работы с данной панелью
double             ExtMinValue[];    // минимальные значения свойств, которые они могут принимать в процессе работы с данной панелью
double             ExtStep[];        // шаги для изменений свойств
int                ExtCount;         // общее количество всех свойств
color              ExtColors[2];     // массив цветов для отображения строк
string             ExtComments[2];   // массив комментариев (для свойства CHART_COMMENT)
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- выведем комментарий на график
   Comment("SomeComment");
//--- сохраним цвета в массив для дальнейшего переключения между ними
   ExtColors[0]=InpFirstColor;
   ExtColors[1]=InpSecondColor;
//--- сохраним комментарии в массив для дальнейшего переключения между ними
   ExtComments[0]="FirstComment";
   ExtComments[1]="SecondComment";
//--- подготовим и отобразим панель управления свойствами графика
   if(!PrepareControls())
      return(INIT_FAILED);
//--- успешное выполнение
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Deinitialization function of the expert                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- очищаем текст комментария на графике
   Comment("");
  }
//+------------------------------------------------------------------+
//| Обработчик событий графика                                       |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- проверка события нажатия на объект графика
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- разобьем имя объекта по разделителю
      string obj_name[];
      StringSplit(sparam,'_',obj_name);
      //--- проверка, является ли объект кнопкой
      if(obj_name[0]=="Button")
        {
         //--- получаем индекс кнопки
         int index=(int)StringToInteger(obj_name[1]);
         //--- установим кнопку в ненажатое состояние
         ExtButtons[index].State(false);
         //--- установим новое значения свойства в зависимости от его типа
         if(ExtDataTypes[index]=='I')
            ChangeIntegerProperty(index);
         if(ExtDataTypes[index]=='D')
            ChangeDoubleProperty(index);
         if(ExtDataTypes[index]=='S')
            ChangeStringProperty(index);
        }
     }
//--- перерисовка значений свойств
   RedrawProperties();
   ChartRedraw();
  }
//+------------------------------------------------------------------+
//| Изменение целочисленного свойства графика                        |
//+------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
  {
//--- получаем текущее значение свойства
   long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index]);
//--- определяем следующее значение свойства
   switch(ExtDrawTypes[index])
     {
      case 'C':
         value=GetNextColor((color)value);
         break;
      default:
         value=(long)GetNextValue((double)value,index);
         break;
     }
//--- устанавливаем новое значение свойства
   ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index],0,value);
  }
//+------------------------------------------------------------------+
//| Изменение вещественного свойства графика                         |
//+------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
  {
//--- получаем текущее значение свойства
   double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index]);
//--- определяем следующее значение свойства
   value=GetNextValue(value,index);
//--- устанавливаем новое значение свойства
   ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index],value);
  }
//+------------------------------------------------------------------+
//| Изменение строкового свойства графика                            |
//+------------------------------------------------------------------+
void ChangeStringProperty(const int index)
  {
//--- статическая переменная для переключения внутри массива комментариев ExtComments
   static uint comment_index=1;
//--- меняем индекс для получения другого комментария
   comment_index=1-comment_index;
//--- устанавливаем новое значение свойства
   ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[index],ExtComments[comment_index]);
  }
//+------------------------------------------------------------------+
//| Определение следующего значения свойства                         |
//+------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
  {
   if(value+ExtStep[index]<=ExtMaxValue[index])
      return(value+ExtStep[index]);
   else
      return(ExtMinValue[index]);
  }
//+------------------------------------------------------------------+
//| Получение следующего цвета для свойства типа color               |
//+------------------------------------------------------------------+
color GetNextColor(const color clr)
  {
//--- вернем следующее значение цвета
   switch(clr)
     {
      case clrWhite: return(clrRed);
      case clrRed:   return(clrGreen);
      case clrGreen: return(clrBlue);
      case clrBlue:  return(clrBlack);
      default:       return(clrWhite);
     }
  }
//+------------------------------------------------------------------+
//| Перерисовка значений свойств                                     |
//+------------------------------------------------------------------+
void RedrawProperties(void)
  {
//--- текст значения свойства
   string text;
   long   value;
//--- цикл по количеству свойств
   for(int i=0;i<ExtCount;i++)
     {
      text="";
      switch(ExtDataTypes[i])
        {
         case 'I':
            //--- получаем текущее значение свойства
            if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[i],0,value))
            break;
            //--- текст целочисленного свойства
            switch(ExtDrawTypes[i])
              {
               //--- свойство цвета
               case 'C':
                  text=(string)((color)value);
                  break;
                  //--- булевое свойство
               case 'B':
                  text=(string)((bool)value);
                  break;
                  //--- свойство перечисления ENUM_CHART_MODE
               case 'M':
                  text=EnumToString((ENUM_CHART_MODE)value);
                  break;
                  //--- свойство перечисления ENUM_CHART_VOLUME_MODE
               case 'V':
                  text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
                  break;
                  //--- число типа int
               default:
                  text=IntegerToString(value);
                  break;
              }
            break;
         case 'D':
            //--- текст вещественного свойства
            text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[i]),4);
            break;
         case 'S':
            //--- текст строкового свойства
            text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[i]);
            break;
        }
      //--- отобразим значение свойства
      ExtLabelsValue[i].Description(text);
     }
  }
//+------------------------------------------------------------------+
//| Создание панели для управления свойствами графика                |
//+------------------------------------------------------------------+
bool PrepareControls(void)
  {
//--- выделим память под массивы с запасом
   MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- переменные
   int i=0;     // переменная цикла
   int col_1=0; // количество свойств в первом столбце
   int col_2=0; // количество свойств во втором столбце
   int col_3=0; // количество свойств в третьем столбце
//--- текущее количество свойств - 0
   ExtCount=0;
//--- ищем свойства в цикле
   while(i<=LAST_PROPERTY_NUMBER)
     {
      //--- запомним текущий номер свойства
      ExtNumbers[ExtCount]=i;
      //--- увеличим значение переменной цикла
      i++;
      //--- проверим, есть ли свойство с таким номером
      if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
        {
         //--- создаем элементы управления для свойства
         switch(ExtGroupTypes[ExtCount])
           {
            case 1:
               //--- создаем надписи и кнопку для свойства
               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);
               //--- количество элементов в первом столбце увеличилось
               col_1++;
               break;
            case 2:
               //--- создаем надписи и кнопку для свойства
               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);
               //--- количество элементов во втором столбце увеличилось
               col_2++;
               break;
            case 3:
               //--- создаем только надписи для свойства
               if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,false))
               return(false);
               //--- количество элементов в третьем столбце увеличилось
               col_3++;
               break;
           }
         //--- определим максимальное, минимальное значение свойства и шаг
         GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
         //--- увеличим количество свойств
         ExtCount++;
        }
     }
//--- освободим память, которая не используется массивами
   MemoryAllocation(ExtCount);
//--- перерисуем значения свойств
   RedrawProperties();
   ChartRedraw();
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Выделение памяти для массивов                                    |
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Проверяем индекс свойства на принадлежность к одному из          |
//| перечислений ENUM_CHART_PROPERTIES                               |
//+------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
  {
//--- проверяем, является ли свойство целочисленным
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind);
   if(_LastError==0)
     {
      data_type='I';                      // свойство из перечисления ENUM_CHART_PROPERTY_INTEGER
      GetTypes(ind,group_type,draw_type); // определим параметры отображения свойства
      return(true);
     }
//--- проверяем, является ли свойство вещественным
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind);
   if(_LastError==0)
     {
      data_type='D';                      // свойство из перечисления ENUM_CHART_PROPERTY_DOUBLE
      GetTypes(ind,group_type,draw_type); // определим параметры отображения свойства
      return(true);
     }
//--- проверяем, является ли свойство строковым
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind);
   if(_LastError==0)
     {
      data_type='S';                      // свойство из перечисления ENUM_CHART_PROPERTY_STRING
      GetTypes(ind,group_type,draw_type); // определим параметры отображения свойства
      return(true);
     }
//--- свойство не принадлежит ни одному перечислению
   return(false);
  }
//+------------------------------------------------------------------+
//| Определение того, в какой группе должно находиться свойство,     |
//| и его тип отображения                                            |
//+------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- проверим на принадлежность свойства к третьей группе
//--- свойства третьей группы отображаются во втором столбце, начиная с CHART_BRING_TO_TOP
   if(CheckThirdGroup(property_number,group_type,draw_type))
      return;
//--- проверим на принадлежность свойства ко второй группе
//--- свойства второй группы отображаются во втором столбце с начала
   if(CheckSecondGroup(property_number,group_type,draw_type))
      return;
//--- если попали сюда, значит свойство принадлежит первой группе (первый столбец)
   CheckFirstGroup(property_number,group_type,draw_type);
  }
//+------------------------------------------------------------------+
//| Функция проверяет, принадлежит ли свойство третьей группе, и     |
//| если да, то определяет его тип отображения                       |
//+------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- проверим свойство на принадлежность к третьей группе
   switch(property_number)
     {
      //--- булевые свойства
      case CHART_IS_OBJECT:
      case CHART_WINDOW_IS_VISIBLE:
         draw_type='B';
         break;
         //--- целочисленные свойства
      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;
         //--- вещественные свойства
      case CHART_PRICE_MIN:
      case CHART_PRICE_MAX:
         draw_type='D';
         break;
         //--- по сути, это свойство является командой показа графика поверх всех других
         //--- для данной панели в его применении нет необходимости, так как окно всегда
         //--- будет становиться поверх всех других раньше, чем мы используем его
      case CHART_BRING_TO_TOP:
         draw_type=' ';
         break;
         //--- свойство не принадлежит к третьей группе
      default:
         return(false);
     }
//--- свойство принадлежит к третьей группе
   group_type=3;
   return(true);
  }
//+------------------------------------------------------------------+
//| Функция проверяет, принадлежит ли свойство второй группе, и если |
//| да, то определяет его тип отображения                            |
//+------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- проверим свойство на принадлежность ко второй группе
   switch(property_number)
     {
      //--- свойство типа ENUM_CHART_MODE
      case CHART_MODE:
         draw_type='M';
         break;
         //--- свойство типа ENUM_CHART_VOLUME_MODE
      case CHART_SHOW_VOLUMES:
         draw_type='V';
         break;
         //--- строковое свойство
      case CHART_COMMENT:
         draw_type='S';
         break;
         //--- свойство цвета
      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;
         //--- свойство не принадлежит ко второй группе
      default:
         return(false);
     }
//--- свойство принадлежит ко второй группе
   group_type=2;
   return(true);
  }
//+------------------------------------------------------------------+
//| Эта функция вызывается только в том случае, если уже известно,   |
//| что свойство не принадлежит второй и третьей группам свойств     |
//+------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- свойство принадлежит первой группе
   group_type=1;
//--- определим тип отображения свойства
   switch(property_number)
     {
      //--- целочисленные свойства
      case CHART_SCALE:
      case CHART_HEIGHT_IN_PIXELS:
         draw_type='I';
         return;
         //--- вещественные свойства
      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;
         //--- остались только булевые свойства
      default:
         draw_type='B';
         return;
     }
  }
//+------------------------------------------------------------------+
//| Создание надписи и кнопки для свойства                           |
//+------------------------------------------------------------------+
bool ShowProperty(const int ind,const int type,const int x1,const int x2,
                  const int xb,const int y,const bool btn)
  {
//--- статический массив для переключения внутри массива цвета ExtColors
   static uint color_index[3]={1,1,1};
//--- меняем индекс для получения другого цвета
   color_index[type]=1-color_index[type];
//--- выведем надписи и кнопку (если btn=true) для свойства
   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);
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Создание надписи                                                 |
//+------------------------------------------------------------------+
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);
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Создание кнопки                                                  |
//+------------------------------------------------------------------+
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);
//--- успешное выполнение
   return(true);
  }
//+------------------------------------------------------------------+
//| Устанавливаем максимальное, минимальное значение свойства и шаг  |
//+------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
  {
   double value;
//--- установим значения в зависимости от типа свойства
   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:
         max=1;
         min=0;
         step=1;
     }
  }

Отображение графиков

Константы объектов