Article-12953-MQL5-SymbolInfo-StringFormat/Article-12953-MQL5-SymbolInfo-Functions.mqh

//+------------------------------------------------------------------+
//|                      Article-12953-MQL5-SymbolInfo-Functions.mqh |
//|                                  Copyright 2026, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Принимает дату в мс, возвращает время в формате Date Time.Msc    |
//+------------------------------------------------------------------+
string TimeMSC(const long time_msc)
  {
   return StringFormat("%s.%.3hu",string((datetime)time_msc / 1000),time_msc % 1000);
   /* Пример вывода:
   2023.07.13 09:31:58.177
   */
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//} что данные по символу идут с задержкой                           |
//+------------------------------------------------------------------+
string SymbolSubscriptionDelay(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Если символа symbol не существует - возвращаем текст ошибки
   if(!SymbolInfoInteger(symbol,SYMBOL_EXIST))
      return StringFormat("%s: Error. Symbol '%s' is not exist",__FUNCTION__,symbol);
//--- Если символ не выбран в окне MarketWatch - пробуем его выбрать
   if(!SymbolInfoInteger(symbol,SYMBOL_SELECT))
     {
      //--- Если не удалось выбрать символ в окне MarketWatch - возвращаем текст ошибки
      if(!SymbolSelect(symbol,true))
         return StringFormat("%s: Failed to select '%s' symbol in MarketWatch. Error %lu",__FUNCTION__,symbol,GetLastError());
     }
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Subscription Delay:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SUBSCRIPTION_DELAY) ? "Yes" : "No");
   /* Пример вывода:
      Subscription Delay: No
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что данные по символу идут с задержкой                           |
//+------------------------------------------------------------------+
void SymbolSubscriptionDelayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSubscriptionDelay(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку сектор экономики,                          |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
string SymbolSector(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение сектора экономики
   ENUM_SYMBOL_SECTOR symbol_sector=(ENUM_SYMBOL_SECTOR)SymbolInfoInteger(symbol,SYMBOL_SECTOR);
//--- "Вырезаем" из строки, полученной из enum, только наименование сектора
   string sector=StringSubstr(EnumToString(symbol_sector),7);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(sector.Lower())
      sector.SetChar(0,ushort(sector.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(sector,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Sector:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,sector);
   /* Пример вывода:
      Sector: Currency
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал сектор экономики, к которому относится символ   |
//+------------------------------------------------------------------+
void SymbolSectorPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSector(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку вид промышленности или отрасль экономики,  |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
string SymbolIndustry(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение вида промышленности
   ENUM_SYMBOL_INDUSTRY symbol_industry=(ENUM_SYMBOL_INDUSTRY)SymbolInfoInteger(symbol,SYMBOL_INDUSTRY);
//--- "Вырезаем" из строки, полученной из enum, только наименование вида промышленности
   string industry=StringSubstr(EnumToString(symbol_industry),9);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(industry.Lower())
      industry.SetChar(0,ushort(industry.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(industry,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Industry:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,industry);
   /* Пример вывода:
      Industry: Undefined
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал вид промышленности или отрасль экономики,       |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
void SymbolIndustryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolIndustry(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ является пользовательским                             |
//+------------------------------------------------------------------+
string SymbolCustom(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Custom symbol:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_CUSTOM) ? "Yes" : "No");
   /* Пример вывода:
   Custom symbol: No
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ является пользовательским                             |
//+------------------------------------------------------------------+
void SymbolCustomPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCustom(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цвет фона, которым подсвечивается          |
//| символ в Market Watch                                            |
//+------------------------------------------------------------------+
string SymbolBackgroundColor(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Background color:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем цвет фона символа в Market Watch
   color back_color=(color)SymbolInfoInteger(symbol,SYMBOL_BACKGROUND_COLOR);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
//--- Если для символа установлен цвет по умолчанию (0xFF000000), то возвращаем 'Default', иначе - его строковое описание
   return StringFormat("%*s%-*s%-s",indent,"",w,header,back_color==0xFF000000 ? "Default" : ColorToString(back_color,true));
   /* Пример вывода:
   Background color: Default
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цвет фона, которым подсвечивается               |
//| символ в Market Watch                                            |
//+------------------------------------------------------------------+
void SymbolBackgroundColorPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBackgroundColor(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку тип цены для построения баров              |
//+------------------------------------------------------------------+
string SymbolChartMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем тип цены для построения баров
   ENUM_SYMBOL_CHART_MODE symbol_chart_mode=(ENUM_SYMBOL_CHART_MODE)SymbolInfoInteger(symbol,SYMBOL_CHART_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование типа цены
   string chart_mode=StringSubstr(EnumToString(symbol_chart_mode),18);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(chart_mode.Lower())
      chart_mode.SetChar(0,ushort(chart_mode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Chart mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,chart_mode);
   /* Пример вывода:
      Chart mode: Bid
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал тип цены для построения баров                   |
//+------------------------------------------------------------------+
void SymbolChartModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolChartMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ с таким именем существует                             |
//+------------------------------------------------------------------+
string SymbolExists(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Exists:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_EXIST) ? "Yes" : "No");
   /* Пример вывода:
   Exists: Yes
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ с таким именем существует                             |
//+------------------------------------------------------------------+
void SymbolExistsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExists(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ выбран в Market Watch                                 |
//+------------------------------------------------------------------+
string SymbolSelected(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Selected:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SELECT) ? "Yes" : "No");
   /* Пример вывода:
   Selected: Yes
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак того, что символ выбран в Market Watch  |
//+------------------------------------------------------------------+
void SymbolSelectedPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSelected(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ отображается в Market Watch                           |
//+------------------------------------------------------------------+
string SymbolVisible(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Visible:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_VISIBLE) ? "Yes" : "No");
   /* Пример вывода:
   Visible: Yes
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ отображается в Market Watch                           |
//+------------------------------------------------------------------+
void SymbolVisiblePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVisible(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку количество сделок в текущей сессии         |
//+------------------------------------------------------------------+
string SymbolSessionDeals(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session deals:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_DEALS));
   /* Пример вывода:
      Session deals: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал количество сделок в текущей сессии              |
//+------------------------------------------------------------------+
void SymbolSessionDealsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionDeals(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку общее число                                |
//| ордеров на покупку в текущий момент                              |
//+------------------------------------------------------------------+
string SymbolSessionBuyOrders(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Buy orders:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_BUY_ORDERS));
   /* Пример вывода:
      Session Buy orders: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал общее число ордеров на покупку в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionBuyOrdersPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionBuyOrders(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку общее число                                |
//| ордеров на продажу в текущий момент                              |
//+------------------------------------------------------------------+
string SymbolSessionSellOrders(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Sell orders:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_BUY_ORDERS));
   /* Пример вывода:
      Session Sell orders: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал общее число ордеров на продажу в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionSellOrdersPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionSellOrders(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку объем в последней сделке                   |
//+------------------------------------------------------------------+
string SymbolVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUME));
   /* Пример вывода:
      Volume: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал объем в последней сделке                        |
//+------------------------------------------------------------------+
void SymbolVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolume(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем за день                 |
//+------------------------------------------------------------------+
string SymbolVolumeHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume high:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUMEHIGH));
   /* Пример вывода:
      Volume high: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем за день                      |
//+------------------------------------------------------------------+
void SymbolVolumeHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeHigh(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем за день                  |
//+------------------------------------------------------------------+
string SymbolVolumeLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUMELOW));
   /* Пример вывода:
      Volume low: 0
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем за день                       |
//+------------------------------------------------------------------+
void SymbolVolumeLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLow(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку время последней котировки                  |
//+------------------------------------------------------------------+
string SymbolTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(string)(datetime)SymbolInfoInteger(symbol,SYMBOL_TIME));
   /* Пример вывода:
      Time: 2023.07.13 21:05:12
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал время последней котировки                       |
//+------------------------------------------------------------------+
void SymbolTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTime(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку время последней котировки в миллисекундах  |
//+------------------------------------------------------------------+
string SymbolTimeMSC(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Time msc:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,TimeMSC(SymbolInfoInteger(symbol,SYMBOL_TIME_MSC)));
   /* Пример вывода:
      Time msc: 2023.07.13 21:09:24.327
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал время последней котировки в миллисекундах       |
//+------------------------------------------------------------------+
void SymbolTimeMSCPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTimeMSC(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку количество знаков после запятой            |
//+------------------------------------------------------------------+
string SymbolDigits(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Digits:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_DIGITS));
   /* Пример вывода:
      Digits: 5
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал количество знаков после запятой                 |
//+------------------------------------------------------------------+
void SymbolDigitsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolDigits(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку размер спреда в пунктах                    |
//+------------------------------------------------------------------+
string SymbolSpread(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Spread:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SPREAD));
   /* Пример вывода:
      Spread: 7
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал размер спреда в пунктах                         |
//+------------------------------------------------------------------+
void SymbolSpreadPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSpread(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку признак плавающего спреда                  |
//+------------------------------------------------------------------+
string SymbolSpreadFloat(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Floating Spread:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SPREAD_FLOAT) ? "Yes" : "No");
   /* Пример вывода:
   Spread float: Yes
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал признак плавающего спреда                       |
//+------------------------------------------------------------------+
void SymbolSpreadFloatPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSpreadFloat(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальное количество                    |
//| показываемых заявок в стакане                                    |
//+------------------------------------------------------------------+
string SymbolTicksBookDepth(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ticks book depth:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_TICKS_BOOKDEPTH));
   /* Пример вывода:
      Ticks book depth: 10
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальное количество                         |
//| показываемых заявок в стакане                                    |
//+------------------------------------------------------------------+
void SymbolTicksBookDepthPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTicksBookDepth(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку способ вычисления стоимости контракта      |
//+------------------------------------------------------------------+
string SymbolTradeCalcMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_CALC_MODE symbol_trade_calc_mode=(ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(symbol,SYMBOL_TRADE_CALC_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_calc_mode=StringSubstr(EnumToString(symbol_trade_calc_mode),17);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_calc_mode.Lower())
      trade_calc_mode.SetChar(0,ushort(trade_calc_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(trade_calc_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade calculation mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_calc_mode);
   /* Пример вывода:
      Trade calculation mode: Forex
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал способ вычисления стоимости контракта           |
//+------------------------------------------------------------------+
void SymbolTradeCalcModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeCalcMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку тип исполнения ордеров                     |
//+------------------------------------------------------------------+
string SymbolTradeMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_TRADE_MODE symbol_trade_mode=(ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(symbol,SYMBOL_TRADE_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_mode=StringSubstr(EnumToString(symbol_trade_mode),18);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_mode.Lower())
      trade_mode.SetChar(0,ushort(trade_mode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_mode);
   /* Пример вывода:
      Trade mode: Full
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал тип исполнения ордеров                          |
//+------------------------------------------------------------------+
void SymbolTradeModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку дату начала торгов по инструменту          |
//+------------------------------------------------------------------+
string SymbolStartTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Start time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   long time=SymbolInfoInteger(symbol,SYMBOL_START_TIME);
   string descr=(time==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s%s",indent,"",w,header,(string)(datetime)time,descr);
   /* Пример вывода:
      Start time: 1970.01.01 00:00:00 (Not used)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал дату начала торгов по инструменту               |
//+------------------------------------------------------------------+
void SymbolSymbolStartTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolStartTime(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку дату окончания торгов по инструменту       |
//+------------------------------------------------------------------+
string SymbolExpirationTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Expiration time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   long time=SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME);
   string descr=(time==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s%s",indent,"",w,header,(string)(datetime)time,descr);
   /* Пример вывода:
      Expiration time: 1970.01.01 00:00:00 (Not used)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал дату окончания торгов по инструменту            |
//+------------------------------------------------------------------+
void SymbolSymbolExpirationTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExpirationTime(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный отступ в пунктах               |
//| от текущей цены закрытиядля установки Stop ордеров               |
//+------------------------------------------------------------------+
string SymbolTradeStopsLevel(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Stops level:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   int stops_level=(int)SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL);
   string descr=(stops_level==0 ? " (By Spread)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu%s",indent,"",w,header,stops_level,descr);
   /* Пример вывода:
      Stops level: 0 (By Spread)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный отступ в пунктах от текущей         |
//| цены закрытия для установки Stop ордеров                         |
//+------------------------------------------------------------------+
void SymbolTradeStopsLevelPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeStopsLevel(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку дистанцию заморозки                        |
//| торговых операций в пунктах                                      |
//+------------------------------------------------------------------+
string SymbolTradeFreezeLevel(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Freeze level:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   int freeze_level=(int)SymbolInfoInteger(symbol,SYMBOL_TRADE_FREEZE_LEVEL);
   string descr=(freeze_level==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu%s",indent,"",w,header,freeze_level,descr);
   /* Пример вывода:
      Freeze level: 0 (Not used)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал дистанцию заморозки торговых операций в пунктах |
//+------------------------------------------------------------------+
void SymbolTradeFreezeLevelPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeFreezeLevel(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку режим заключения сделок                    |
//+------------------------------------------------------------------+
string SymbolTradeExeMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_TRADE_EXECUTION symbol_trade_exemode=(ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(symbol,SYMBOL_TRADE_EXEMODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_exemode=StringSubstr(EnumToString(symbol_trade_exemode),23);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_exemode.Lower())
      trade_exemode.SetChar(0,ushort(trade_exemode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade Execution mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_exemode);
   /* Пример вывода:
      Trade Execution mode: Instant
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал режим заключения сделок                         |
//+------------------------------------------------------------------+
void SymbolTradeExeModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeExeMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку модель расчета свопа                       |
//+------------------------------------------------------------------+
string SymbolSwapMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели расчета свопа
   ENUM_SYMBOL_SWAP_MODE symbol_swap_mode=(ENUM_SYMBOL_SWAP_MODE)SymbolInfoInteger(symbol,SYMBOL_SWAP_MODE);
//--- "Вырезаем" из строки, полученной из enum, только модель расчета свопа
   string swap_mode=StringSubstr(EnumToString(symbol_swap_mode),17);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(swap_mode.Lower())
      swap_mode.SetChar(0,ushort(swap_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(swap_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,swap_mode);
   /* Пример вывода:
      Swap mode: Points
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал модель расчета свопа                            |
//+------------------------------------------------------------------+
void SymbolSwapModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку день недели для начисления тройного свопа  |
//+------------------------------------------------------------------+
string SymbolSwapRollover3Days(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели расчета свопа
   ENUM_DAY_OF_WEEK symbol_swap_rollover3days=(ENUM_DAY_OF_WEEK)SymbolInfoInteger(symbol,SYMBOL_SWAP_ROLLOVER3DAYS);
//--- Переобразуем enum в строку с наименованием дня недели
   string swap_rollover3days=EnumToString(symbol_swap_rollover3days);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(swap_rollover3days.Lower())
      swap_rollover3days.SetChar(0,ushort(swap_rollover3days.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Rollover 3 days:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,swap_rollover3days);
   /* Пример вывода:
      Swap Rollover 3 days: Wednesday
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал день недели для начисления тройного свопа       |
//+------------------------------------------------------------------+
void SymbolSwapRollover3DaysPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapRollover3Days(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку режим расчета                              |
//| хеджированной маржи по наибольшей стороне                        |
//+------------------------------------------------------------------+
string SymbolMarginHedgedUseLeg(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin hedged use leg:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_MARGIN_HEDGED_USE_LEG) ? "Yes" : "No");
   /* Пример вывода:
   Margin hedged use leg: No
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал режим расчета хеджированной                     |
//| маржи по наибольшей стороне                                      |
//+------------------------------------------------------------------+
void SymbolMarginHedgedUseLegPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginHedgedUseLeg(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных режимов истечения ордера |
//+------------------------------------------------------------------+
string SymbolExpirationMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем режимы истечения ордера
   int exp_mode=(int)SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Expiration mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги режимов на составляющие
   string flags="";
   if((exp_mode&SYMBOL_EXPIRATION_GTC)==SYMBOL_EXPIRATION_GTC)
      flags+=(flags.Length()>0 ? "|" : "")+"GTC";
   if((exp_mode&SYMBOL_EXPIRATION_DAY)==SYMBOL_EXPIRATION_DAY)
      flags+=(flags.Length()>0 ? "|" : "")+"DAY";
   if((exp_mode&SYMBOL_EXPIRATION_SPECIFIED)==SYMBOL_EXPIRATION_SPECIFIED)
      flags+=(flags.Length()>0 ? "|" : "")+"SPECIFIED";
   if((exp_mode&SYMBOL_EXPIRATION_SPECIFIED_DAY)==SYMBOL_EXPIRATION_SPECIFIED_DAY)
      flags+=(flags.Length()>0 ? "|" : "")+"SPECIFIED_DAY";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Expiration mode: GTC|DAY|SPECIFIED
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных режимов истечения ордера      |
//+------------------------------------------------------------------+
void SymbolExpirationModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExpirationMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных режимов заливки ордера   |
//+------------------------------------------------------------------+
string SymbolFillingMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем режимы заливки ордера
   int fill_mode=(int)SymbolInfoInteger(symbol,SYMBOL_FILLING_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Filling mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги режимов на составляющие
   string flags="";
   if((fill_mode&ORDER_FILLING_FOK)==ORDER_FILLING_FOK)
      flags+=(flags.Length()>0 ? "|" : "")+"FOK";
   if((fill_mode&ORDER_FILLING_IOC)==ORDER_FILLING_IOC)
      flags+=(flags.Length()>0 ? "|" : "")+"IOC";
   if((fill_mode&ORDER_FILLING_BOC)==ORDER_FILLING_BOC)
      flags+=(flags.Length()>0 ? "|" : "")+"BOC";
   if(SymbolInfoInteger(symbol,SYMBOL_TRADE_EXEMODE)!=SYMBOL_TRADE_EXECUTION_MARKET)
      flags+=(flags.Length()>0 ? "|" : "")+"RETURN";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Filling mode: FOK|IOC|RETURN
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных режимов заливки ордера        |
//+------------------------------------------------------------------+
void SymbolFillingModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolFillingMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных типов ордера             |
//+------------------------------------------------------------------+
string SymbolOrderMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем типы ордера
   int order_mode=(int)SymbolInfoInteger(symbol,SYMBOL_ORDER_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Order mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги типов на составляющие
   string flags="";
   if((order_mode&SYMBOL_ORDER_MARKET)==SYMBOL_ORDER_MARKET)
      flags+=(flags.Length()>0 ? "|" : "")+"MARKET";
   if((order_mode&SYMBOL_ORDER_LIMIT)==SYMBOL_ORDER_LIMIT)
      flags+=(flags.Length()>0 ? "|" : "")+"LIMIT";
   if((order_mode&SYMBOL_ORDER_STOP)==SYMBOL_ORDER_STOP)
      flags+=(flags.Length()>0 ? "|" : "")+"STOP";
   if((order_mode&SYMBOL_ORDER_STOP_LIMIT )==SYMBOL_ORDER_STOP_LIMIT )
      flags+=(flags.Length()>0 ? "|" : "")+"STOP_LIMIT";
   if((order_mode&SYMBOL_ORDER_SL)==SYMBOL_ORDER_SL)
      flags+=(flags.Length()>0 ? "|" : "")+"SL";
   if((order_mode&SYMBOL_ORDER_TP)==SYMBOL_ORDER_TP)
      flags+=(flags.Length()>0 ? "|" : "")+"TP";
   if((order_mode&SYMBOL_ORDER_CLOSEBY)==SYMBOL_ORDER_CLOSEBY)
      flags+=(flags.Length()>0 ? "|" : "")+"CLOSEBY";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Order mode: MARKET|LIMIT|STOP|STOP_LIMIT|SL|TP|CLOSEBY
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных типов ордера                  |
//+------------------------------------------------------------------+
void SymbolOrderModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOrderMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку срок действия StopLoss и TakeProfit ордеров|
//+------------------------------------------------------------------+
string SymbolOrderGTCMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение срока действия отложенных ордеров, StopLoss и TakeProfit ордеров
   ENUM_SYMBOL_ORDER_GTC_MODE symbol_order_gtc_mode=(ENUM_SYMBOL_ORDER_GTC_MODE)SymbolInfoInteger(symbol,SYMBOL_ORDER_GTC_MODE);
//--- Устанавливаем описание срока действия как 'GTC'
   string gtc_mode="GTC";
//--- Если срок действия не GTC
   if(symbol_order_gtc_mode!=SYMBOL_ORDERS_GTC)
     {
      //--- "Вырезаем" из строки, полученной из enum, только описание срока действия отложенных ордеров, StopLoss и TakeProfit ордеров
      StringSubstr(EnumToString(symbol_order_gtc_mode),14);
      //--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
      if(gtc_mode.Lower())
         gtc_mode.SetChar(0,ushort(gtc_mode.GetChar(0)-0x20));
      //--- Заменяем в полученной строке все символы подчёркивания на символ пробела
      StringReplace(gtc_mode,"_"," ");
     }
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Order GTC mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,gtc_mode);
   /* Пример вывода:
      Order GTC mode: GTC
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал срок действия  StopLoss и TakeProfit ордеров    |
//+------------------------------------------------------------------+
void SymbolOrderGTCModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOrderGTCMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку тип опциона                                |
//+------------------------------------------------------------------+
string SymbolOptionMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели типа опциона
   ENUM_SYMBOL_OPTION_MODE symbol_option_mode=(ENUM_SYMBOL_OPTION_MODE)SymbolInfoInteger(symbol,SYMBOL_OPTION_MODE);
//--- "Вырезаем" из строки, полученной из enum, только тип опциона
   string option_mode=StringSubstr(EnumToString(symbol_option_mode),19);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(option_mode.Lower())
      option_mode.SetChar(0,ushort(option_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(option_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,option_mode);
   /* Пример вывода:
      Option mode: European
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал тип опциона                                     |
//+------------------------------------------------------------------+
void SymbolOptionModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionMode(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку право опциона                              |
//+------------------------------------------------------------------+
string SymbolOptionRight(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение права опциона
   ENUM_SYMBOL_OPTION_RIGHT symbol_option_right=(ENUM_SYMBOL_OPTION_RIGHT)SymbolInfoInteger(symbol,SYMBOL_OPTION_RIGHT);
//--- "Вырезаем" из строки, полученной из enum, только право опциона
   string option_right=StringSubstr(EnumToString(symbol_option_right),20);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(option_right.Lower())
      option_right.SetChar(0,ushort(option_right.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(option_right,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option right:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,option_right);
   /* Пример вывода:
      Option right: Call
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал право опциона                                   |
//+------------------------------------------------------------------+
void SymbolOptionRightPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionRight(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену Bid                                   |
//+------------------------------------------------------------------+
string SymbolBid(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BID));
   /* Пример вывода:
   Bid: 1.31017
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену Bid                                        |
//+------------------------------------------------------------------+
void SymbolBidPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBid(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Bid за день                   |
//+------------------------------------------------------------------+
string SymbolBidHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BIDHIGH));
   /* Пример вывода:
   Bid High: 1.31422
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Bid за день                        |
//+------------------------------------------------------------------+
void SymbolBidHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBidHigh(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Bid за день                    |
//+------------------------------------------------------------------+
string SymbolBidLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BIDLOW));
   /* Пример вывода:
   Bid Low: 1.30934
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Bid за день                         |
//+------------------------------------------------------------------+
void SymbolBidLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBidLow(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену Ask                                   |
//+------------------------------------------------------------------+
string SymbolAsk(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASK));
   /* Пример вывода:
   Ask: 1.31060
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену Ask                                        |
//+------------------------------------------------------------------+
void SymbolAskPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAsk(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Ask за день                   |
//+------------------------------------------------------------------+
string SymbolAskHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASKHIGH));
   /* Пример вывода:
   Ask High: 1.31427
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Ask за день                        |
//+------------------------------------------------------------------+
void SymbolAskHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAskHigh(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Ask за день                    |
//+------------------------------------------------------------------+
string SymbolAskLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASKLOW));
   /* Пример вывода:
   Ask Low: 1.30938
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Ask за день                         |
//+------------------------------------------------------------------+
void SymbolAskLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAskLow(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену Last                                  |
//+------------------------------------------------------------------+
string SymbolLast(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LAST));
   /* Пример вывода:
   Last: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену Last                                       |
//+------------------------------------------------------------------+
void SymbolLastPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLast(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Last за день                  |
//+------------------------------------------------------------------+
string SymbolLastHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LASTHIGH));
   /* Пример вывода:
   Last High: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Last за день                       |
//+------------------------------------------------------------------+
void SymbolLastHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLastHigh(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Last за день                   |
//+------------------------------------------------------------------+
string SymbolLastLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LASTLOW));
   /* Пример вывода:
   Last Low: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Last за день                        |
//+------------------------------------------------------------------+
void SymbolLastLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLastLow(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку объем последней совершенной сделки         |
//+------------------------------------------------------------------+
string SymbolVolumeReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUME_REAL));
   /* Пример вывода:
   Volume real: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал объем последней совершенной сделки              |
//+------------------------------------------------------------------+
void SymbolVolumeRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeReal(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем за день                 |
//+------------------------------------------------------------------+
string SymbolVolumeHighReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume High real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUMEHIGH_REAL));
   /* Пример вывода:
   Volume High real: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем за день                      |
//+------------------------------------------------------------------+
void SymbolVolumeHighRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeHighReal(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем за день                  |
//+------------------------------------------------------------------+
string SymbolVolumeLowReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume Low real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUMELOW_REAL));
   /* Пример вывода:
   Volume Low real: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем за день                       |
//+------------------------------------------------------------------+
void SymbolVolumeLowRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLowReal(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену исполнения опциона                    |
//+------------------------------------------------------------------+
string SymbolOptionStrike(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option strike:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_OPTION_STRIKE));
   /* Пример вывода:
   Option strike: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену исполнения опциона                         |
//+------------------------------------------------------------------+
void SymbolOptionStrikePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionStrike(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку значение одного пункта                     |
//+------------------------------------------------------------------+
string SymbolPoint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Point:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_POINT));
   /* Пример вывода:
   Point: 0.00001
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал значение одного пункта                          |
//+------------------------------------------------------------------+
void SymbolPointPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPoint(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку стоимость тика                             |
//+------------------------------------------------------------------+
string SymbolTradeTickValue(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE));
   /* Пример вывода:
   Tick value: 1.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал стоимость тика                                  |
//+------------------------------------------------------------------+
void SymbolTradeTickValuePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValue(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку рассчитанную стоимость тика                |
//| для прибыльной позиции                                           |
//+------------------------------------------------------------------+
string SymbolTradeTickValueProfit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value profit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE_PROFIT));
   /* Пример вывода:
   Tick value profit: 1.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал рассчитанную стоимость тика                     |
//| для прибыльной позиции                                           |
//+------------------------------------------------------------------+
void SymbolTradeTickValueProfitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValueProfit(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку рассчитанную стоимость тика                |
//| для убыточной позиции                                            |
//+------------------------------------------------------------------+
string SymbolTradeTickValueLoss(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value loss:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE_LOSS));
   /* Пример вывода:
   Tick value loss: 1.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал рассчитанную стоимость тика                     |
//| для убыточной позиции                                            |
//+------------------------------------------------------------------+
void SymbolTradeTickValueLossPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValueLoss(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальное изменение цены                 |
//+------------------------------------------------------------------+
string SymbolTradeTickSize(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick size:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE));
   /* Пример вывода:
   Tick size: 0.00001
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальное изменение цены                      |
//+------------------------------------------------------------------+
void SymbolTradeTickSizePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickSize(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку размер торгового контракта                 |
//+------------------------------------------------------------------+
string SymbolTradeContractSize(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Contract size:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE),SymbolInfoString(symbol,SYMBOL_CURRENCY_BASE));
   /* Пример вывода:
   Contract size: 100000.00 GBP
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал размер торгового контракта                      |
//+------------------------------------------------------------------+
void SymbolTradeContractSizePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeContractSize(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку накопленный купонный доход                 |
//+------------------------------------------------------------------+
string SymbolTradeAccruedInterest(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Accrued interest:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_ACCRUED_INTEREST));
   /* Пример вывода:
   Accrued interest: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал накопленный купонный доход                      |
//+------------------------------------------------------------------+
void SymbolTradeAccruedInterestPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeAccruedInterest(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку номинальную стоимость                      |
//+------------------------------------------------------------------+
string SymbolTradeFaceValue(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Face value:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_FACE_VALUE));
   /* Пример вывода:
   Face value: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал номинальную стоимость                           |
//+------------------------------------------------------------------+
void SymbolTradeFaceValuePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeFaceValue(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент ликвидности                    |
//+------------------------------------------------------------------+
string SymbolTradeLiquidityRate(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Liquidity rate:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_LIQUIDITY_RATE));
   /* Пример вывода:
   Liquidity rate: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент ликвидности                         |
//+------------------------------------------------------------------+
void SymbolTradeLiquidityRatePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeLiquidityRate(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем                          |
//+------------------------------------------------------------------+
string SymbolVolumeMin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume min:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN));
   /* Пример вывода:
   Volume min: 0.01
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем                               |
//+------------------------------------------------------------------+
void SymbolVolumeMinPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeMin(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем                         |
//+------------------------------------------------------------------+
string SymbolVolumeMax(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume max:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX));
   /* Пример вывода:
   Volume max: 500.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем                              |
//+------------------------------------------------------------------+
void SymbolVolumeMaxPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeMax(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимальный шаг изменения объема           |
//+------------------------------------------------------------------+
string SymbolVolumeStep(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume step:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP));
   /* Пример вывода:
   Volume step: 0.01
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимальный шаг изменения объема                |
//+------------------------------------------------------------------+
void SymbolVolumeStepPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeStep(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимально допустимый для символа         |
//| совокупный объем открытой позиции и отложенных ордеров           |
//+------------------------------------------------------------------+
string SymbolVolumeLimit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume limit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_LIMIT));
   /* Пример вывода:
   Volume limit: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимально допустимый для символа              |
//| совокупный объем открытой позиции и отложенных ордеров           |
//+------------------------------------------------------------------+
void SymbolVolumeLimitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLimit(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку значение свопа в покупку                   |
//+------------------------------------------------------------------+
string SymbolSwapLong(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap long:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SWAP_LONG));
   /* Пример вывода:
   Swap long: -0.20
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал значение свопа в покупку                        |
//+------------------------------------------------------------------+
void SymbolSwapLongPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapLong(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку значение свопа в продажу                   |
//+------------------------------------------------------------------+
string SymbolSwapShort(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap short:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SWAP_SHORT));
   /* Пример вывода:
   Swap short: -2.20
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал значение свопа в продажу                        |
//+------------------------------------------------------------------+
void SymbolSwapShortPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapShort(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с воскресения на понедельник                |
//+------------------------------------------------------------------+
string SymbolSwapSunday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap sunday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_SUNDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap sunday: 0 (no swap is charged)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с воскресения на понедельник                |
//+------------------------------------------------------------------+
void SymbolSwapSundayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapSunday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с понедельника на вторник                   |
//+------------------------------------------------------------------+
string SymbolSwapMonday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap monday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_MONDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap monday: 1 (single swap)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с понедельника на вторник                   |
//+------------------------------------------------------------------+
void SymbolSwapMondayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapMonday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции со вторника на среду                        |
//+------------------------------------------------------------------+
string SymbolSwapTuesday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Tuesday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_TUESDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap Tuesday: 1 (single swap)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции со вторника на среду                        |
//+------------------------------------------------------------------+
void SymbolSwapTuesdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapTuesday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции со среды на четверг                         |
//+------------------------------------------------------------------+
string SymbolSwapWednesday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Wednesday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_WEDNESDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Wednesday: 3 (triple swap)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции со среды на четверг                         |
//+------------------------------------------------------------------+
void SymbolSwapWednesdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapWednesday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с четверга на пятницу                       |
//+------------------------------------------------------------------+
string SymbolSwapThursday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Thursday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_THURSDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Thursday: 1 (single swap)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с четверга на пятницу                       |
//+------------------------------------------------------------------+
void SymbolSwapThursdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapThursday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с пятницы на субботу                        |
//+------------------------------------------------------------------+
string SymbolSwapFriday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Friday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_FRIDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Friday: 1 (single swap)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с пятницы на субботу                        |
//+------------------------------------------------------------------+
void SymbolSwapFridayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapFriday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с субботы на воскресенье                    |
//+------------------------------------------------------------------+
string SymbolSwapSaturday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Saturday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_SATURDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Saturday: 0 (no swap is charged)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с субботы на воскресенье                    |
//+------------------------------------------------------------------+
void SymbolSwapSaturdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapSaturday(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| по указанному дню недели                                         |
//+------------------------------------------------------------------+
string SymbolSwapByDay(const string symbol,const ENUM_DAY_OF_WEEK day_week,const uint header_width=0,const uint indent=0)
  {
//--- Получаем текстовое описание дня недели
   string day=EnumToString(day_week);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(day.Lower())
      day.SetChar(0,ushort(day.GetChar(0)-0x20));
//--- Создаём текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header=StringFormat("Swap %s:",day);
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Объявляем свойство, которое необходимо запросить в SymbolInfoDouble()
   int prop=SYMBOL_SWAP_SUNDAY;
//--- В зависимости от дня недели указываем запрашиваемое свойство
   switch(day_week)
     {
      case MONDAY       : prop=SYMBOL_SWAP_MONDAY;    break;
      case TUESDAY      : prop=SYMBOL_SWAP_TUESDAY;   break;
      case WEDNESDAY    : prop=SYMBOL_SWAP_WEDNESDAY; break;
      case THURSDAY     : prop=SYMBOL_SWAP_THURSDAY;  break;
      case FRIDAY       : prop=SYMBOL_SWAP_FRIDAY;    break;
      case SATURDAY     : prop=SYMBOL_SWAP_SATURDAY;  break;
      default/*SUNDAY*/ : prop=SYMBOL_SWAP_SUNDAY;    break;
     }
//--- Получаем коэффициент по выбранному свойству и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,(ENUM_SYMBOL_INFO_DOUBLE)prop);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Sunday: 0 (no swap is charged)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| по указанному дню недели                                         |
//+------------------------------------------------------------------+
void SymbolSwapByDayPrint(const string symbol,const ENUM_DAY_OF_WEEK day_week,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapByDay(symbol,day_week,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку начальную (инициирующую) маржу             |
//+------------------------------------------------------------------+
string SymbolMarginInitial(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin initial:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_INITIAL),SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN));
   /* Пример вывода:
      Margin initial: 0.00 GBP
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал начальную (инициирующую) маржу                  |
//+------------------------------------------------------------------+
void SymbolMarginInitialPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginInitial(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку поддерживающую маржу по инструменту        |
//+------------------------------------------------------------------+
string SymbolMarginMaintenance(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin maintenance:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_MAINTENANCE),SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN));
   /* Пример вывода:
      Margin maintenance: 0.00 GBP
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал поддерживающую маржу по инструменту             |
//+------------------------------------------------------------------+
void SymbolMarginMaintenancePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginMaintenance(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку суммарный объём сделок в текущую сессию    |
//+------------------------------------------------------------------+
string SymbolSessionVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_VOLUME));
   /* Пример вывода:
      Session volume: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал суммарный объём сделок в текущую сессию         |
//+------------------------------------------------------------------+
void SymbolSessionVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionVolume(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку суммарный оборот в текущую сессию          |
//+------------------------------------------------------------------+
string SymbolSessionTurnover(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session turnover:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_TURNOVER));
   /* Пример вывода:
      Session turnover: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал суммарный оборот в текущую сессию               |
//+------------------------------------------------------------------+
void SymbolSessionTurnoverPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionTurnover(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку суммарный объём открытых позиций           |
//+------------------------------------------------------------------+
string SymbolSessionInterest(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session interest:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_INTEREST));
   /* Пример вывода:
      Session interest: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал суммарный объём открытых позиций                |
//+------------------------------------------------------------------+
void SymbolSessionInterestPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionInterest(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку общий объём ордеров на покупку             |
//| в текущий момент                                                 |
//+------------------------------------------------------------------+
string SymbolSessionBuyOrdersVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Buy orders volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_BUY_ORDERS_VOLUME));
   /* Пример вывода:
      Session Buy orders volume: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал общий объём ордеров на покупку в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionBuyOrdersVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionBuyOrdersVolume(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку общий объём ордеров на продажу             |
//| в текущий момент                                                 |
//+------------------------------------------------------------------+
string SymbolSessionSellOrdersVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Sell orders volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_SELL_ORDERS_VOLUME));
   /* Пример вывода:
      Session Sell orders volume: 0.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал общий объём ордеров на продажу в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionSellOrdersVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionSellOrdersVolume(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену открытия сессии                       |
//+------------------------------------------------------------------+
string SymbolSessionOpen(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Open:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_OPEN));
   /* Пример вывода:
      Session Open: 1.31314
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену открытия сессии                            |
//+------------------------------------------------------------------+
void SymbolSessionOpenPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionOpen(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену закрытия сессии                       |
//+------------------------------------------------------------------+
string SymbolSessionClose(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Close:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_CLOSE));
   /* Пример вывода:
      Session Close: 1.31349
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену закрытия сессии                            |
//+------------------------------------------------------------------+
void SymbolSessionClosePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionClose(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку средневзвешенную цену сессии               |
//+------------------------------------------------------------------+
string SymbolSessionAW(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session AW:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_AW));
   /* Пример вывода:
      Session AW: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал средневзвешенную цену сессии                    |
//+------------------------------------------------------------------+
void SymbolSessionAWPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionAW(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку цену поставки на текущую сессию            |
//+------------------------------------------------------------------+
string SymbolSessionPriceSettlement(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price settlement:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_SETTLEMENT));
   /* Пример вывода:
      Session price settlement: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал цену поставки на текущую сессию                 |
//+------------------------------------------------------------------+
void SymbolSessionPriceSettlementPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceSettlement(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку минимально допустимое                      |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
string SymbolSessionPriceLimitMin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price limit min:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_LIMIT_MIN));
   /* Пример вывода:
      Session price limit min: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал минимально допустимое                           |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
void SymbolSessionPriceLimitMinPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceLimitMin(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку максимально допустимое                     |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
string SymbolSessionPriceLimitMax(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price limit max:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_LIMIT_MAX));
   /* Пример вывода:
      Session price limit max: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал максимально допустимое                          |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
void SymbolSessionPriceLimitMaxPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceLimitMax(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку размер контракта или маржи                 |
//| для одного лота перекрытых позиций                               |
//+------------------------------------------------------------------+
string SymbolMarginHedged(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin hedged:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_HEDGED));
   /* Пример вывода:
      Margin hedged: 100000.00
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал размер контракта или маржи                      |
//| для одного лота перекрытых позиций                               |
//+------------------------------------------------------------------+
void SymbolMarginHedgedPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginHedged(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку изменение текущей цены относительно        |
//| конца предыдущего торгового дня, выраженное в процентах          |
//+------------------------------------------------------------------+
string SymbolPriceChange(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price change:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f %%",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_PRICE_CHANGE));
   /* Пример вывода:
      Price change: -0.28 %
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал изменение текущей цены относительно             |
//| конца предыдущего торгового дня, выраженное в процентах          |
//+------------------------------------------------------------------+
void SymbolPriceChangePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceChange(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку волатильность цены в процентах             |
//+------------------------------------------------------------------+
string SymbolPriceVolatility(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price volatility:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %%",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_PRICE_VOLATILITY));
   /* Пример вывода:
      Price volatility: 0.00 %
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал волатильность цены в процентах                  |
//+------------------------------------------------------------------+
void SymbolPriceVolatilityPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceVolatility(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку теоретическую цену опциона                 |
//+------------------------------------------------------------------+
string SymbolPriceTheoretical(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price theoretical:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_THEORETICAL));
   /* Пример вывода:
      Price theoretical: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал теоретическую цену опциона                      |
//+------------------------------------------------------------------+
void SymbolPriceTheoreticalPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceTheoretical(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку дельту опциона/варранта                    |
//+------------------------------------------------------------------+
string SymbolPriceDelta(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price delta:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_DELTA));
   /* Пример вывода:
      Price delta: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал дельту опциона/варранта                         |
//+------------------------------------------------------------------+
void SymbolPriceDeltaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceDelta(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку тету опциона/варранта                      |
//+------------------------------------------------------------------+
string SymbolPriceTheta(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price theta:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_THETA));
   /* Пример вывода:
      Price theta: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал тету опциона/варранта                           |
//+------------------------------------------------------------------+
void SymbolPriceThetaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceTheta(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку гамму опциона/варранта                     |
//+------------------------------------------------------------------+
string SymbolPriceGamma(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price gamma:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_GAMMA));
   /* Пример вывода:
      Price gamma: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал гамму опциона/варранта                          |
//+------------------------------------------------------------------+
void SymbolPriceGammaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceGamma(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку вегу опциона/варранта                      |
//+------------------------------------------------------------------+
string SymbolPriceVega(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price vega:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_VEGA));
   /* Пример вывода:
      Price vega: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал вегу опциона/варранта                           |
//+------------------------------------------------------------------+
void SymbolPriceVegaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceVega(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку ро опциона/варранта                        |
//+------------------------------------------------------------------+
string SymbolPriceRho(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price rho:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_RHO));
   /* Пример вывода:
      Price rho: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал ро опциона/варранта                             |
//+------------------------------------------------------------------+
void SymbolPriceRhoPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceRho(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку омегу опциона/варранта                     |
//+------------------------------------------------------------------+
string SymbolPriceOmega(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price omega:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_OMEGA));
   /* Пример вывода:
      Price omega: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал омегу опциона/варранта                          |
//+------------------------------------------------------------------+
void SymbolPriceOmegaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceOmega(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает как строку чувствительность опциона/варранта          |
//+------------------------------------------------------------------+
string SymbolPriceSensitivity(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price sensitivity:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_SENSITIVITY));
   /* Пример вывода:
      Price sensitivity: 0.00000
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал чувствительность опциона/варранта               |
//+------------------------------------------------------------------+
void SymbolPriceSensitivityPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceSensitivity(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает имя базового актива для производного инструмента      |
//+------------------------------------------------------------------+
string SymbolBasis(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Basis:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_BASIS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Basis: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал имя базового актива для производного инструмента|
//+------------------------------------------------------------------+
void SymbolBasisPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBasis(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает название категории или сектора финансового инструмента|
//+------------------------------------------------------------------+
string SymbolCategory(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Category:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CATEGORY);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Category: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал название категории или сектора                  |
//| финансового инструмента                                          |
//+------------------------------------------------------------------+
void SymbolCategoryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCategory(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает страну, к которой отнесен финансовый инструмент       |
//+------------------------------------------------------------------+
string SymbolCountry(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Country:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_COUNTRY);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Country: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал страну, к которой отнесен финансовый инструмент |
//+------------------------------------------------------------------+
void SymbolCountryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCountry(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает сектор экономики,                                     |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
string SymbolSectorName(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Sector name:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_SECTOR_NAME);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Sector name: 'Currency'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал сектор экономики,                               |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
void SymbolSectorNamePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSectorName(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает отрасль экономики или вид промышленности,             |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
string SymbolIndustryName(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Industry name:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_INDUSTRY_NAME);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Industry name: 'Undefined'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал отрасль экономики или вид промышленности,       |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
void SymbolIndustryNamePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolIndustryName(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает базовую валюту инструмента                            |
//+------------------------------------------------------------------+
string SymbolCurrencyBase(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency base:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_BASE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency base: 'GBP'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал базовую валюту инструмента                      |
//+------------------------------------------------------------------+
void SymbolCurrencyBasePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyBase(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает валюту прибыли                                        |
//+------------------------------------------------------------------+
string SymbolCurrencyProfit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency profit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_PROFIT);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency profit: 'USD'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал валюту прибыли                                  |
//+------------------------------------------------------------------+
void SymbolCurrencyProfitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyProfit(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает валюту, в которой вычисляются залоговые средства      |
//+------------------------------------------------------------------+
string SymbolCurrencyMargin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency margin:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency margin: 'GBP'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал валюту, в которой вычисляются залоговые средства|
//+------------------------------------------------------------------+
void SymbolCurrencyMarginPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyMargin(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает источник текущей котировки                            |
//+------------------------------------------------------------------+
string SymbolBank(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bank:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_BANK);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Bank: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал источник текущей котировки                      |
//+------------------------------------------------------------------+
void SymbolBankPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBank(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает строковое описание символа                            |
//+------------------------------------------------------------------+
string SymbolDescription(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Description:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_DESCRIPTION);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Description: 'Pound Sterling vs US Dollar'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал строковое описание символа                      |
//+------------------------------------------------------------------+
void SymbolDescriptionPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolDescription(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает название биржи или торговой площадки,                 |
//| на которой торгуется символ                                      |
//+------------------------------------------------------------------+
string SymbolExchange(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Exchange:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_EXCHANGE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Exchange: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал название биржи или торговой площадки,           |
//| на которой торгуется символ                                      |
//+------------------------------------------------------------------+
void SymbolExchangePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExchange(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает формулу для построения цены пользовательского символа |
//+------------------------------------------------------------------+
string SymbolFormula(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Formula:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_FORMULA);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Formula: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал формулу для построения                          |
//| цены пользовательского символа                                   |
//+------------------------------------------------------------------+
void SymbolFormulaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolFormula(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает имя торгового символа в системе                       |
//| международных идентификационных кодов ценных бумаг               |
//+------------------------------------------------------------------+
string SymbolISIN(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="ISIN:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_ISIN);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      ISIN: '' (Not specified)
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал имя торгового символа в системе                 |
//| международных идентификационных кодов ценных бумаг               |
//+------------------------------------------------------------------+
void SymbolISINPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolISIN(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает адрес интернет страницы с информацией по символу      |
//+------------------------------------------------------------------+
string SymbolPage(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Page:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_PAGE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Page: 'https://www.mql5.com/en/quotes/currencies/gbpusd'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал адрес интернет страницы с информацией по символу|
//+------------------------------------------------------------------+
void SymbolPagePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPage(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Возвращает путь в дереве символов                                |
//+------------------------------------------------------------------+
string SymbolPath(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Path:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_PATH);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Path: 'Forex\GBPUSD'
   */
  }
//+------------------------------------------------------------------+
//| Выводит в журнал путь в дереве символов                          |
//+------------------------------------------------------------------+
void SymbolPathPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPath(symbol,header_width,indent));
  }
//+------------------------------------------------------------------+
//| Выводит в журнал все свойства символа                            |
//+------------------------------------------------------------------+
void SymbolInfoPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Выводим в журнал описания целочисленных свойств в порядке их расположения в ENUM_SYMBOL_INFO_INTEGER
   Print("SymbolInfoInteger properties:");
   SymbolSubscriptionDelayPrint(symbol,header_width,indent);
   SymbolSectorPrint(symbol,header_width,indent);
   SymbolIndustryPrint(symbol,header_width,indent);
   SymbolCustomPrint(symbol,header_width,indent);
   SymbolBackgroundColorPrint(symbol,header_width,indent);
   SymbolChartModePrint(symbol,header_width,indent);
   SymbolExistsPrint(symbol,header_width,indent);
   SymbolSelectedPrint(symbol,header_width,indent);
   SymbolVisiblePrint(symbol,header_width,indent);
   SymbolSessionDealsPrint(symbol,header_width,indent);
   SymbolSessionBuyOrdersPrint(symbol,header_width,indent);
   SymbolSessionSellOrdersPrint(symbol,header_width,indent);
   SymbolVolumePrint(symbol,header_width,indent);
   SymbolVolumeHighPrint(symbol,header_width,indent);
   SymbolVolumeLowPrint(symbol,header_width,indent);
   SymbolTimePrint(symbol,header_width,indent);
   SymbolTimeMSCPrint(symbol,header_width,indent);
   SymbolDigitsPrint(symbol,header_width,indent);
   SymbolSpreadPrint(symbol,header_width,indent);
   SymbolSpreadFloatPrint(symbol,header_width,indent);
   SymbolTicksBookDepthPrint(symbol,header_width,indent);
   SymbolTradeCalcModePrint(symbol,header_width,indent);
   SymbolTradeModePrint(symbol,header_width,indent);
   SymbolSymbolStartTimePrint(symbol,header_width,indent);
   SymbolSymbolExpirationTimePrint(symbol,header_width,indent);
   SymbolTradeStopsLevelPrint(symbol,header_width,indent);
   SymbolTradeFreezeLevelPrint(symbol,header_width,indent);
   SymbolTradeExeModePrint(symbol,header_width,indent);
   SymbolSwapModePrint(symbol,header_width,indent);
   SymbolSwapRollover3DaysPrint(symbol,header_width,indent);
   SymbolMarginHedgedUseLegPrint(symbol,header_width,indent);
   SymbolExpirationModePrint(symbol,header_width,indent);
   SymbolFillingModePrint(symbol,header_width,indent);
   SymbolOrderModePrint(symbol,header_width,indent);
   SymbolOrderGTCModePrint(symbol,header_width,indent);
   SymbolOptionModePrint(symbol,header_width,indent);
   SymbolOptionRightPrint(symbol,header_width,indent);

//--- Выводим в журнал описания вещественных свойств в порядке их расположения в ENUM_SYMBOL_INFO_DOUBLE
   Print("SymbolInfoDouble properties:");
   SymbolBidPrint(symbol,header_width,indent);
   SymbolBidHighPrint(symbol,header_width,indent);
   SymbolBidLowPrint(symbol,header_width,indent);
   SymbolAskPrint(symbol,header_width,indent);
   SymbolAskHighPrint(symbol,header_width,indent);
   SymbolAskLowPrint(symbol,header_width,indent);
   SymbolLastPrint(symbol,header_width,indent);
   SymbolLastHighPrint(symbol,header_width,indent);
   SymbolLastLowPrint(symbol,header_width,indent);
   SymbolVolumeRealPrint(symbol,header_width,indent);
   SymbolVolumeHighRealPrint(symbol,header_width,indent);
   SymbolVolumeLowRealPrint(symbol,header_width,indent);
   SymbolOptionStrikePrint(symbol,header_width,indent);
   SymbolPointPrint(symbol,header_width,indent);
   SymbolTradeTickValuePrint(symbol,header_width,indent);
   SymbolTradeTickValueProfitPrint(symbol,header_width,indent);
   SymbolTradeTickValueLossPrint(symbol,header_width,indent);
   SymbolTradeTickSizePrint(symbol,header_width,indent);
   SymbolTradeContractSizePrint(symbol,header_width,indent);
   SymbolTradeAccruedInterestPrint(symbol,header_width,indent);
   SymbolTradeFaceValuePrint(symbol,header_width,indent);
   SymbolTradeLiquidityRatePrint(symbol,header_width,indent);
   SymbolVolumeMinPrint(symbol,header_width,indent);
   SymbolVolumeMaxPrint(symbol,header_width,indent);
   SymbolVolumeStepPrint(symbol,header_width,indent);
   SymbolVolumeLimitPrint(symbol,header_width,indent);
   SymbolSwapLongPrint(symbol,header_width,indent);
   SymbolSwapShortPrint(symbol,header_width,indent);
   SymbolSwapByDayPrint(symbol,SUNDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,MONDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,TUESDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,WEDNESDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,THURSDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,FRIDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,SATURDAY,header_width,indent);
   SymbolMarginInitialPrint(symbol,header_width,indent);
   SymbolMarginMaintenancePrint(symbol,header_width,indent);
   SymbolSessionVolumePrint(symbol,header_width,indent);
   SymbolSessionTurnoverPrint(symbol,header_width,indent);
   SymbolSessionInterestPrint(symbol,header_width,indent);
   SymbolSessionBuyOrdersVolumePrint(symbol,header_width,indent);
   SymbolSessionSellOrdersVolumePrint(symbol,header_width,indent);
   SymbolSessionOpenPrint(symbol,header_width,indent);
   SymbolSessionClosePrint(symbol,header_width,indent);
   SymbolSessionAWPrint(symbol,header_width,indent);
   SymbolSessionPriceSettlementPrint(symbol,header_width,indent);
   SymbolSessionPriceLimitMinPrint(symbol,header_width,indent);
   SymbolSessionPriceLimitMaxPrint(symbol,header_width,indent);
   SymbolMarginHedgedPrint(symbol,header_width,indent);
   SymbolPriceChangePrint(symbol,header_width,indent);
   SymbolPriceVolatilityPrint(symbol,header_width,indent);
   SymbolPriceTheoreticalPrint(symbol,header_width,indent);
   SymbolPriceDeltaPrint(symbol,header_width,indent);
   SymbolPriceThetaPrint(symbol,header_width,indent);
   SymbolPriceGammaPrint(symbol,header_width,indent);
   SymbolPriceVegaPrint(symbol,header_width,indent);
   SymbolPriceRhoPrint(symbol,header_width,indent);
   SymbolPriceOmegaPrint(symbol,header_width,indent);
   SymbolPriceSensitivityPrint(symbol,header_width,indent);
   
//--- Выводим в журнал описания строковых свойств в порядке их расположения в ENUM_SYMBOL_INFO_STRING
   Print("SymbolInfoString properties:");
   SymbolBasisPrint(symbol,header_width,indent);
   SymbolCategoryPrint(symbol,header_width,indent);
   SymbolCountryPrint(symbol,header_width,indent);
   SymbolSectorNamePrint(symbol,header_width,indent);
   SymbolIndustryNamePrint(symbol,header_width,indent);
   SymbolCurrencyBasePrint(symbol,header_width,indent);
   SymbolCurrencyProfitPrint(symbol,header_width,indent);
   SymbolCurrencyMarginPrint(symbol,header_width,indent);
   SymbolBankPrint(symbol,header_width,indent);
   SymbolDescriptionPrint(symbol,header_width,indent);
   SymbolExchangePrint(symbol,header_width,indent);
   SymbolFormulaPrint(symbol,header_width,indent);
   SymbolISINPrint(symbol,header_width,indent);
   SymbolPagePrint(symbol,header_width,indent);
   SymbolPathPrint(symbol,header_width,indent);
  }
//+------------------------------------------------------------------+