دانلود اندیکاتور کانال فیبو – Download Channels FIBO indicator

دسامبر 8th, 2021 ام کیو ال و اتو تریدینگ اندیکاتور

5 / 0

به این مقاله امتیاز دهید.

دانلود اندیکاتور Channels FIBO برای متاتریدر 4

توضیحات دانــــلود دیدگاه ها

دانلود اندیکاتور Channels FIBO برای متاتریدر 4

دانلود اندیکاتور کانال فیبو – Download Channels FIBO indicator

برچسب‌ها :

Channels FIBO اندیکاتور فیبو کانال متاتریدر

مقالات مرتبط

اکتبر 29th, 2023 بایگانی‌ها

5 / 0

Desi FX Machine دانلود و معرفی اکسپرت

معرفی و دانلود اکسپرت کاربردی Desi FX Machine اکسپرت کاربردی Desi FX Machine فارکس یک تجارت کاملاً خودکار با سیستم معاملاتی “سفارش معلق” است که به ویژه در معاملات جفت ارزهای محبوب مؤثر است. معرفی اکسپرت کاربردی Desi FX Machine EA SETUP EA را روی همه نمودارهای جداگانه اجرا کنید: GBPNZD,GBPCAD,AUDCAD,NZDCAD,GBPAUD,GBPJPY,GBPCAD,GBPCHF,USDCAD,USDJPY,NZDCHF,ERUCHF بازه زمانی برای همه […]

0 ادامه مقاله

آگوست 18th, 2023 بایگانی‌ها

5 / 0

Dark Mimas MT5 دانلود و معرفی اکسپرت

معرفی و دانلود اکسپرت کاربردی Dark Mimas MT5 Dark Mimas MT5 یک مشاور متخصص کاملا اتوماتیک برای تجارت اسکالپینگ است. این مشاور متخصص نیاز به توجه دارد، در واقع بسیار قابل تنظیم است. معرفی اکسپرت کاربردی Dark Mimas MT5 Dark Mimas بر اساس شاخص Dark Oscillator MT5 است، این معاملات را می توان با برخی […]

0 ادامه مقاله

مارس 21st, 2023 بایگانی‌ها

5 / 5

Bollinger Bands Cross Alert دانلود و معرفی اندیکاتور

معرفی و دانلود اندیکاتور Bollinger Bands Cross Alert اندیکاتور Bollinger Bands Cross Alert ورودی و خروجی دقیق استراتژی شما را با استفاده از یک الگوریتم مجتمع خودکار محاسبه می کند تا هنگام عبور قیمت از باندهای بولینگر به شما هشدار دهد. معرفی اندیکاتور Bollinger Bands Cross Alert سوالات متداول: این BB Cross چه تفاوتی با […]

0 ادامه مقاله

آخرین مقالات

جولای 4th, 2024 بایگانی‌ها

5 / 0

Session Colored Bars With High Low MT5

معرفی و دانلود اندیکاتور کاربردی Session Colored Bars With High Low اگر از یک استراتژی مبتنی بر جلسه پیروی می کنید، ممکن است شاخص Session Colored Bars With High Low برای شما مفید باشد.همه چیز قابل تنظیم است. اندیکاتور کاربردی Session Colored Bars With High Low میله ها با توجه به جلسات رنگی می شوند. […]

0 ادامه مقاله

جولای 4th, 2024 بایگانی‌ها

5 / 0

RSI Divergence AW دانلود اندیکاتور MT5

معرفی و دانلود اندیکاتور کاربردی RSI Divergence AW RSI Divergence AW نشانگر واگرایی بین RSI و قیمت، که به شما امکان می دهد سیگنالی در مورد تغییر روند به موقع دریافت کنید یا حرکات عقب نشینی قیمت را بگیرید. اندیکاتور کاربردی RSI Divergence AW تنظیمات نشانگر به شما این امکان را می دهد که قدرت […]

0 ادامه مقاله

جولای 3rd, 2024 بایگانی‌ها

5 / 0

SetupMediasATR دانلود اندیکاتور MT5

معرفی و دانلود اندیکاتور کاربردی SetupMediasATR SetupMediasATR 2 میانگین را با فاصله 1 ATR از میانگین اصلی چاپ می کند. میانگین های متحرک باقیمانده تنها در صورتی نشان داده می شوند که خارج از این محدوده باشند. اندیکاتور کاربردی SetupMediasATR پارامتر های اندیکاتور SetupMediasATR : میانگین اصلی = میانگینی که فاصله ایجاد خواهد شد، نشان […]

0 ادامه مقاله

بخش دانلود

فایل های که پسوند آنها rar یا zip یا 7z هست را چگونه باز کنم؟
توسط نرم افزار Winrar فایل را از حالت فشرده خارج کنید و بعد برای اجرا و یا نصب اقدام کنید. دانلود WINRAR

فایل های با فرمت mq4 و mq5 را چگونه اجرا کنم ؟
جهت اجرای این نوع فایل ها برای نسخه mq4 باید متاتریدر 4 را روی سیستم خود و برای نسخه mq5 متاتریدر 5 را روی سیستم عامل خود نصب داشته باشید . جهت راهنمایی کلیک کنید

به این مقاله امتیاز دهید.
رمز تمامی فایل ها :

دانلود اندیکاتور Channels FIBO

کد فایل

//+------------------------------------------------------------------+
//|                                           ChannelsFIBO_v2_AD.mq4 |
//|                                        Copyright 2016, Scriptong |
//|                                          http://advancetools.net |
//+------------------------------------------------------------------+
#property copyright "Scriptong"
#property link      "http://advancetools.net"
#property description   "English: Dynamic channel, which is calculated based on the maximum distance between the price and MA.\nRussian: Äèíàìè÷åñêèé êàíàë, ðàññ÷èòàííûé íà îñíîâàíèè ìàêñèìàëüíîãî ðàññòîÿíèÿ ìåæäó öåíîé è MA."
#property strict

#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1 clrRed
#property indicator_color2 clrDarkOrange
#property indicator_color3 clrYellow
#property indicator_color4 clrAquamarine
#property indicator_color5 clrMagenta
#property indicator_color6 clrYellow
#property indicator_color7 clrDarkOrange
#property indicator_color8 clrRed

#property indicator_width4 2
#property indicator_width5 2

#property indicator_style1 STYLE_DOT
#property indicator_style2 STYLE_DOT
#property indicator_style3 STYLE_DOT
#property indicator_style6 STYLE_DOT
#property indicator_style7 STYLE_DOT
#property indicator_style8 STYLE_DOT
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_SHIFT_METHOD
  {
   SHIFT_MAXIMUM,                                                                                  // By maximal shift / Ïî ìàêñèìàëüíîìó ñìåùåíèþ
   SHIFT_AVERAGE,                                                                                  // By average shift / Ïî ñðåäíåìó ñìåùåíèþ
   SHIFT_MEDIAN,                                                                                   // By median shift / Ïî ìåäèàííîìó ñìåùåíèþ
   SHIFT_STD                                                                                       // By standart deviation / Ïî ÑÊÎ
  };

input    uint                 i_extremumDepth            = 78;                                     // Depth extremum search / Ãëóáèíà ïîèñêà ýêñòðåìóìà
input    uint                 i_maPeriod                 = 100;                                    // MA period / Ïåðèîä MA
input    ENUM_MA_METHOD       i_maMethod                 = MODE_SMA;                               // MA method / Ìåòîä ðàñ÷åòà ÌÀ
input    ENUM_APPLIED_PRICE   i_maPrice                  = PRICE_CLOSE;                            // MA price / Öåíà ðàñ÷åòà ÌÀ
input    double               i_fiboLevel1               = 61.8;                                   // Fibo level 1 / Óðîâåíü Ôèáî 1
input    double               i_fiboLevel2               = 100.0;                                  // Fibo level 2 / Óðîâåíü Ôèáî 2
input    double               i_fiboLevel3               = 161.8;                                  // Fibo level 3 / Óðîâåíü Ôèáî 3
input    double               i_fiboLevel4               = 200.0;                                  // Fibo level 4 / Óðîâåíü Ôèáî 4
input    ENUM_SHIFT_METHOD    i_shiftMethod              = SHIFT_STD;                              // Channel calculate method / Ìåòîä ðàñ÷åòà êàíàëà
input    int                  i_indBarsCount             = 10000;                                  // Number of bars to display / Êîë-âî áàðîâ îòîáðàæåíèÿ

#define PREFIX                                        "CHAFIB2_"
#define FONT_NAME                                     "Tahoma"
#define FONT_SIZE                                     8

bool g_activate;

double   g_fiboLevel[4],
         g_priceShifts[],
         g_tempPriceShifts[],
         g_point,
         g_delta;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_MESSAGE_CODE
  {
   MESSAGE_CODE_WRONG_DEPTH,
   MESSAGE_CODE_WRONG_MA_PERIOD,
   MESSAGE_CODE_TERMINAL_FATAL_ERROR1,
   MESSAGE_CODE_ENOUGH_MEMORY,
   MESSAGE_CODE_FIBO_EQUALS,
   MESSAGE_CODE_BIND_ERROR
  };

// The indicator's buffers
double g_buffHigh1[];
double g_buffHigh2[];
double g_buffHigh3[];
double g_buffHigh4[];
double g_buffLow1[];
double g_buffLow2[];
double g_buffLow3[];
double g_buffLow4[];
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Custom indicator initialization function                                                                                                                                                          |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
int OnInit()
  {
   g_activate=false;

   if(!TuningParameters())
      return INIT_FAILED;

   if(!BuffersBind())
      return INIT_FAILED;

   g_activate=true;

   return INIT_SUCCEEDED;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Checking the correctness of values of tuning parameters                                                                                                                                           |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
bool TuningParameters()
  {
   string name=WindowExpertName();

   if(i_extremumDepth<1)
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_WRONG_DEPTH));
      return false;
     }

   if(ArrayResize(g_priceShifts,i_extremumDepth)<0)
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_ENOUGH_MEMORY));
      return false;
     }

   if(ArrayResize(g_tempPriceShifts,i_extremumDepth)<0)
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_ENOUGH_MEMORY));
      return false;
     }

   if(i_maPeriod<1)
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_WRONG_MA_PERIOD));
      return false;
     }

   g_point = Point;
   g_delta = -g_point / 10;
   if(g_point==0)
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_TERMINAL_FATAL_ERROR1));
      return false;
     }

   g_fiboLevel[0] = i_fiboLevel1;
   g_fiboLevel[1] = i_fiboLevel2;
   g_fiboLevel[2] = i_fiboLevel3;
   g_fiboLevel[3] = i_fiboLevel4;
   if(!IsFiboLevelsUnique())
      return false;

   ArraySort(g_fiboLevel);

   return true;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Are unique the specified fibo levels?                                                                                                                                                             |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
bool IsFiboLevelsUnique()
  {
   for(int i=0; i<3; i++)
      for(int j=i+1; j<4; j++)
         if(MathAbs(g_fiboLevel[i]-g_fiboLevel[j])<=DBL_EPSILON)
           {
            Alert(WindowExpertName(),GetStringByMessageCode(MESSAGE_CODE_FIBO_EQUALS));
            return false;
           }

   return true;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Custom indicator deinitialization function                                                                                                                                                        |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0,PREFIX);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Binding of array and the indicator buffers                                                                                                                                                        |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
bool BuffersBind()
  {
   string name=WindowExpertName();

   if(!SetIndexBuffer(0,g_buffHigh1) || 
      !SetIndexBuffer(1,g_buffHigh2) || 
      !SetIndexBuffer(2,g_buffHigh3) || 
      !SetIndexBuffer(3,g_buffHigh4) || 
      !SetIndexBuffer(4,g_buffLow1) || 
      !SetIndexBuffer(5,g_buffLow2) || 
      !SetIndexBuffer(6,g_buffLow3) || 
      !SetIndexBuffer(7,g_buffLow4))
     {
      Alert(name,GetStringByMessageCode(MESSAGE_CODE_BIND_ERROR),GetLastError());
      return false;
     }

   for(int i=0; i<8; i++)
     {
      SetIndexStyle(i,DRAW_LINE);
      if(i<4)
         SetIndexLabel(i,"Upper "+DoubleToString(g_fiboLevel[3-i],2)+"%");
      else
         SetIndexLabel(i,"Lower "+DoubleToString(g_fiboLevel[i-4],2)+"%");
     }

   return true;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Initialize of all indicator buffers                                                                                                                                                               |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void BuffersInitializeAll()
  {
   ArrayInitialize(g_buffHigh4,EMPTY_VALUE);
   ArrayInitialize(g_buffHigh3,EMPTY_VALUE);
   ArrayInitialize(g_buffHigh2,EMPTY_VALUE);
   ArrayInitialize(g_buffHigh1,EMPTY_VALUE);
   ArrayInitialize(g_buffLow1,EMPTY_VALUE);
   ArrayInitialize(g_buffLow2,EMPTY_VALUE);
   ArrayInitialize(g_buffLow3,EMPTY_VALUE);
   ArrayInitialize(g_buffLow4,EMPTY_VALUE);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Determination of bar index which needed to recalculate                                                                                                                                            |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
int GetRecalcIndex(int &total,const int ratesTotal,const int prevCalculated)
  {
   total=ratesTotal-int(i_extremumDepth+i_maPeriod);

   if(i_indBarsCount>0 && i_indBarsCount<total)
      total=MathMin(i_indBarsCount,total);

   if(prevCalculated<ratesTotal-1)
     {
      BuffersInitializeAll();
      return total;
     }

   return (MathMin(ratesTotal - prevCalculated, total));
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Calculate of price shift at the specified bar                                                                                                                                                     |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
double GetPriceShift(int barIndex)
  {
   double ma=iMA(NULL,0,i_maPeriod,0,i_maMethod,i_maPrice,barIndex);
   double highShift= MathAbs(ma-iHigh(NULL,0,barIndex));
   double lowShift = MathAbs(ma-iLow(NULL,0,barIndex));

   return MathMax(highShift, lowShift);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Calculate of expectation value                                                                                                                                                                    |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
double GetExpectation(double &expectationX2)
  {
   double summ=0.0,summX2=0.0;
   for(int i=0; i<int(i_extremumDepth); i++)
     {
      summ+=g_priceShifts[i];
      summX2+=g_priceShifts[i]*g_priceShifts[i];
     }

   expectationX2=summX2/i_extremumDepth;
   return summ / i_extremumDepth;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Calculation of median value                                                                                                                                                                       |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
double CalculateMedian(void)
  {
   ArrayCopy(g_tempPriceShifts,g_priceShifts);
   if(!ArraySort(g_tempPriceShifts))
      return 0.0;

   int middleElement=(int)i_extremumDepth/2;
   if(i_extremumDepth%2==1)
      return g_tempPriceShifts[middleElement];

   return (g_tempPriceShifts[middleElement] + g_tempPriceShifts[middleElement - 1]) / 2;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Calculation of channel shift value                                                                                                                                                                |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
double GetChannelShiftValue()
  {
   int i=0;
   double expect=0.0,expectX2=0.0;
   switch(i_shiftMethod)
     {
      case SHIFT_MAXIMUM:     i=ArrayMaximum(g_priceShifts);
      if(i>=0 && i<int(i_extremumDepth))
         return g_priceShifts[i];
      return 0.0;

      case SHIFT_AVERAGE:     return GetExpectation(expectX2);

      case SHIFT_MEDIAN:      return CalculateMedian();

      case SHIFT_STD:         expect=GetExpectation(expectX2);
      return MathSqrt(expectX2 - expect * expect);
     }

   return 0.0;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Primary filling of array of price shifts                                                                                                                                                          |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void InitializePriceShifts(int limit)
  {
   for(int i=int(limit+i_extremumDepth-1); i>=limit; i--)
      g_priceShifts[i-limit]=GetPriceShift(i);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Moving up the elements in array g_priceShifts                                                                                                                                                     |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void MovePriceShifts()
  {
   for(int i=int(i_extremumDepth)-1; i>0; i--)
      g_priceShifts[i]=g_priceShifts[i-1];
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Îòîáðàæåíèå îáúåêòà "Òåêñò"                                                                                                                                                                       |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void ShowText(string name,datetime time,double price,string text,color clr)
  {
   if(ObjectFind(0,name)<0)
     {
      ObjectCreate(0,name,OBJ_TEXT,0,time,price);
      ObjectSetString(0,name,OBJPROP_FONT,FONT_NAME);
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,FONT_SIZE);
      ObjectSetString(0,name,OBJPROP_TEXT,text);
      ObjectSetString(0,name,OBJPROP_TOOLTIP,"\n");
      ObjectSetInteger(0,name,OBJPROP_COLOR,clr);
      ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT);
      ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
      return;
     }

   ObjectMove(0,name,0,time,price);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Show the descriptions for each Fibo level                                                                                                                                                         |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void ShowDescriptions()
  {
   datetime time=iTime(NULL,0,0)+PeriodSeconds();
   ShowText(PREFIX+"HIGH1",time,g_buffHigh1[0],DoubleToString(g_fiboLevel[3],2)+"%",indicator_color1);
   ShowText(PREFIX+"HIGH2",time,g_buffHigh2[0],DoubleToString(g_fiboLevel[2],2)+"%",indicator_color2);
   ShowText(PREFIX+"HIGH3",time,g_buffHigh3[0],DoubleToString(g_fiboLevel[1],2)+"%",indicator_color3);
   ShowText(PREFIX+"HIGH4",time,g_buffHigh4[0],DoubleToString(g_fiboLevel[0],2)+"%",indicator_color4);
   ShowText(PREFIX+"LOW1",time,g_buffLow1[0],DoubleToString(g_fiboLevel[0],2)+"%",indicator_color5);
   ShowText(PREFIX+"LOW2",time,g_buffLow2[0],DoubleToString(g_fiboLevel[1],2)+"%",indicator_color6);
   ShowText(PREFIX+"LOW3",time,g_buffLow3[0],DoubleToString(g_fiboLevel[2],2)+"%",indicator_color7);
   ShowText(PREFIX+"LOW4",time,g_buffLow4[0],DoubleToString(g_fiboLevel[3],2)+"%",indicator_color8);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Show the channels values at the specified bar                                                                                                                                                     |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void ShowChannel(int barIndex)
  {
   double ma=iMA(NULL,0,i_maPeriod,0,i_maMethod,i_maPrice,barIndex);
   double shift=GetChannelShiftValue();
   g_buffHigh1[barIndex] = ma + shift * g_fiboLevel[3] / 100.0;
   g_buffHigh2[barIndex] = ma + shift * g_fiboLevel[2] / 100.0;
   g_buffHigh3[barIndex] = ma + shift * g_fiboLevel[1] / 100.0;
   g_buffHigh4[barIndex] = ma + shift * g_fiboLevel[0] / 100.0;
   g_buffLow1[barIndex] = ma - shift * g_fiboLevel[0] / 100.0;
   g_buffLow2[barIndex] = ma - shift * g_fiboLevel[1] / 100.0;
   g_buffLow3[barIndex] = ma - shift * g_fiboLevel[2] / 100.0;
   g_buffLow4[barIndex] = ma - shift * g_fiboLevel[3] / 100.0;

   if(barIndex==0)
      ShowDescriptions();
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Calculation of indicators values                                                                                                                                                                  |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
void CalcIndicatorData(int limit,int total)
  {
   if(limit>1)
      InitializePriceShifts(limit);

   for(int i=limit; i>=0; i--)
     {
      g_priceShifts[0]=GetPriceShift(i);
      ShowChannel(i);

      if(i>0)
         MovePriceShifts();
     }
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Custom indicator iteration function                                                                                                                                                               |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   iTime(NULL,0,0);
   if(GetLastError()!=ERR_NO_ERROR)
      return prev_calculated;

   int total;
   int limit=GetRecalcIndex(total,rates_total,prev_calculated);

   CalcIndicatorData(limit,total);

   return rates_total;
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Getting string by code of message and terminal language                                                                                                                                           |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
string GetStringByMessageCode(ENUM_MESSAGE_CODE messageCode)
  {
   string language=TerminalInfoString(TERMINAL_LANGUAGE);
   if(language=="Russian")
      return GetRussianMessage(messageCode);

   return GetEnglishMessage(messageCode);
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Getting string by code of message for russian language                                                                                                                                            |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
string GetRussianMessage(ENUM_MESSAGE_CODE messageCode)
  {
   switch(messageCode)
     {
      case MESSAGE_CODE_WRONG_DEPTH:                       return ": ïåðèîä ïîèñêà ýêñòðåìóìà äîëæåí áûòü áîëåå 0. Èíäèêàòîð îòêëþ÷åí.";
      case MESSAGE_CODE_WRONG_MA_PERIOD:                   return ": ïåðèîä ðàñ÷åòà ÌÀ äîëæåí áûòü áîëåå 0. Èíäèêàòîð îòêëþ÷åí.";
      case MESSAGE_CODE_TERMINAL_FATAL_ERROR1:             return ": ôàòàëüíàÿ îøèáêà òåðìèíàëà - ïóíêò ðàâåí íóëþ. Èíäèêàòîð îòêëþ÷åí.";
      case MESSAGE_CODE_ENOUGH_MEMORY:                     return ": îøèáêà ðàñïðåäåëåíèÿ ïàìÿòè äëÿ ìàññèâà. Èíäèêàòîð îòêëþ÷åí.";
      case MESSAGE_CODE_FIBO_EQUALS:                       return ": ñðåäè óêàçàííûõ Ôèáî-óðîâíåé îáíàðóæåíû ïîâòîðåíèÿ çíà÷åíèé. Èíäèêàòîð îòêëþ÷åí.";
      case MESSAGE_CODE_BIND_ERROR:                        return ": îøèáêà ñâÿçûâàíèÿ ìàññèâîâ ñ áóôåðàìè èíäèêàòîðà. Îøèáêà ¹";
     }

   return "";
  }
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//| Getting string by code of message for english language                                                                                                                                            |
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
string GetEnglishMessage(ENUM_MESSAGE_CODE messageCode)
  {
   switch(messageCode)
     {
      case MESSAGE_CODE_WRONG_DEPTH:                       return ": the depth of extremum search must be greater than 0. The indicator is turned off.";
      case MESSAGE_CODE_WRONG_MA_PERIOD:                   return ": MA calculation period must be greater than 0. The indicator is turned off.";
      case MESSAGE_CODE_TERMINAL_FATAL_ERROR1:             return ": terminal fatal error - point equals to zero. The indicator is turned off.";
      case MESSAGE_CODE_ENOUGH_MEMORY:                     return ": not enough of memory for array. The indicator is turned off.";
      case MESSAGE_CODE_FIBO_EQUALS:                       return ": two or more Fibo levels are equals. The indicator is turned off.";
      case MESSAGE_CODE_BIND_ERROR:                        return ": error of binding of the arrays and the indicator buffers. Error N";
     }

   return "";
  }
//+------------------------------------------------------------------+

ویدیو های آموزشی فارسی

کتاب های آموزش فارکس

کتاب های آموزش بورس

مطالعه مقالات بازار بورس

مطالعه مقالات بازار فارکس

مطالعه مقالات ارز های دیجیتال

معرفی بروکر های بازار فارکس

استراتژی ها و ابزار های معاملاتی

فرهنگ تخصصی لغات

ویدیو های آموزشی انگلیسی

دانلود کتاب ها و مقالات انگلیسی

دانلود اکسپرت های معاملاتی

دانلود اندیکاتور های کاربردی

دانلود اسکریپت های کاربردی

دانلود اندیکاتور کانال فیبو – Download Channels FIBO indicator

برچسب‌ها :

مقالات مرتبط

Desi FX Machine دانلود و معرفی اکسپرت

Dark Mimas MT5 دانلود و معرفی اکسپرت

Bollinger Bands Cross Alert دانلود و معرفی اندیکاتور

آخرین مقالات

Session Colored Bars With High Low MT5

RSI Divergence AW دانلود اندیکاتور MT5

SetupMediasATR دانلود اندیکاتور MT5

بخش دانلود

کد فایل