CCFp_Close_v1[1].1vert

Download script
Author: SemSemFX@rambler.ru
CCFp_Close_v1[1].1vert

This script is designed as a multi-currency correlation and strength indicator for MetaTrader. It provides a visual summary of how different major currencies are performing relative to one another, specifically focusing on their relationship with common base pairs.

Core Functionality

The primary purpose of this tool is to track the "strength" or movement of eight major currencies (USD, EUR, GBP, CHF, JPY, AUD, CAD, and NZD). Instead of just looking at a single price chart, it calculates the percentage change across various currency interactions simultaneously.

How the Logic Works

1. Data Collection and Normalization The script monitors several specific currency pairs (such as EURUSD, GBPUSD, USDJPY, etc.). To create a unified view, it looks at the closing prices of the last two completed candles for each enabled pair. By comparing these two points, the script determines the immediate momentum of each currency.

2. Cross-Currency Calculations The logic doesn't just look at one pair; it calculates the relative movement of each currency against all others. For example:

  • To determine USD strength, it aggregates its performance against EUR, GBP, AUD, NZD, CHF, CAD, and JPY.
  • For other currencies (like EUR or GBP), it performs more complex "cross-calculations." This involves mathematically combining different pairs to isolate the specific movement of that single currency regardless of what it is being traded against.

3. Visual Representation The script translates these complex mathematical calculations into a simple, readable text display on a separate window in your trading platform:

  • Dynamic Labels: It creates a list showing each currency name followed by a symbol (+, -, or =) representing the direction of the movement.
  • Comparative Data: Next to the symbols, it displays the specific values for the previous price points and the calculated difference.
  • Color Coding: Each currency is assigned a unique color (e.g., USD in Green, GBP in Red, JPY in Maroon) to help traders quickly distinguish between different assets at a glance.

Key Features for the User

  • Customizable Visibility: You can toggle specific currencies on or off. If you only care about USD and EUR, you can disable the others to declutter your screen.
  • Smart Symbol Handling: The script is designed to automatically recognize different broker naming conventions (such as those adding suffixes like "m" or "i" to currency names), ensuring the data remains accurate across different trading platforms.
  • Real-Time Updates: The indicator refreshes its calculations with every new candle, providing an up-to-date snapshot of market sentiment and currency strength.
Price Data Components
Series array that contains close prices for each bar
Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
CCFp_Close_v1[1].1vert 
//+------------------------------------------------------------------+
//|                                                  CCFp_v1.0.2.mq4 |
//|                                              SemSemFX@rambler.ru |
//|              http://onix-trade.net/forum/index.php?showtopic=107 |
//|                        Modifed version by Skyline on 09 Oct 2008 |
//+------------------------------------------------------------------+
// Rev. v1.0.1 ** Added +/-/= symbols to show strength of last 2 closed candles
//             ** Added IBFX symbols management
// Rev. v1.0.2 ** Fixed symbols paint issue whenever a new candle starts

#property copyright "SemSemFX@rambler.ru"
#property link      "http://onix-trade.net/forum/index.php?showtopic=107"
//----
extern string Indicator_ID = "CCFocv2:";
int Objs = 0;
//----
#property indicator_separate_window
#property indicator_buffers 8
extern bool USD = true;
extern bool EUR = true;
extern bool GBP = true;
extern bool CHF = true;
extern bool JPY = true;
extern bool AUD = true;
extern bool CAD = true;
extern bool NZD = true;
extern color Color_USD = Green;
extern color Color_EUR = Aqua;
extern color Color_GBP = Red;
extern color Color_CHF = Chocolate;
extern color Color_JPY = Maroon;
extern color Color_AUD = DarkOrange;
extern color Color_CAD = Purple;
extern color Color_NZD = Teal;
extern int Line_Thickness = 2;
extern int All_Bars = 200;
extern int Last_Bars = 0;
extern int Y_Top = 14;
extern int Y_Step = 15;
extern int TxtSize = 10;

//----
double arrUSD[];
double arrEUR[];
double arrGBP[];
double arrCHF[];
double arrJPY[];
double arrAUD[];
double arrCAD[];
double arrNZD[];

double   myPoint;
string Indicator_Name;
   string sAUDUSD,sEURUSD,sUSDCHF,sNZDUSD,sGBPUSD,sUSDJPY,sUSDCAD;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators

   Indicator_Name = Indicator_ID;

   IndicatorShortName(Indicator_Name);


   int width = 0;
   if(0 > StringFind(Symbol(), "USD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(0, DRAW_LINE, DRAW_LINE, width, Color_USD);
   SetIndexBuffer(0, arrUSD);
   SetIndexLabel(0, "USD"); 
   if(0 > StringFind(Symbol(), "EUR", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(1, DRAW_LINE, DRAW_LINE, width, Color_EUR);
   SetIndexBuffer(1, arrEUR);
   SetIndexLabel(1, "EUR"); 
   if(0 > StringFind(Symbol(), "GBP", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(2, DRAW_LINE, DRAW_LINE, width, Color_GBP);
   SetIndexBuffer(2, arrGBP);
   SetIndexLabel(2, "GBP"); 
   if(0 > StringFind(Symbol(), "CHF", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(3, DRAW_LINE, DRAW_LINE, width, Color_CHF);
   SetIndexBuffer(3, arrCHF);
   SetIndexLabel(3, "CHF"); 
   if(0 > StringFind(Symbol(), "JPY", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(4, DRAW_LINE, DRAW_LINE, width, Color_JPY);
   SetIndexBuffer(4, arrJPY);
   SetIndexLabel(4, "JPY"); 
   if(0 > StringFind(Symbol(), "AUD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(5, DRAW_LINE, DRAW_LINE, width, Color_AUD);
   SetIndexBuffer(5, arrAUD);
   SetIndexLabel(5, "AUD"); 
   if(0 > StringFind(Symbol(), "CAD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(6, DRAW_LINE, DRAW_LINE, width, Color_CAD);
   SetIndexBuffer(6, arrCAD);
   SetIndexLabel(6, "CAD"); 
   if(0 > StringFind(Symbol(), "NZD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(7, DRAW_LINE, DRAW_LINE, width, Color_NZD);
   SetIndexBuffer(7, arrNZD);
   SetIndexLabel(7, "NZD"); 
//----

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   for(int i = 0; i < Objs; i++)
     {
      if(!ObjectDelete(Indicator_Name + i))
          Print("error: code #", GetLastError());
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   string AddChar;
   int limit;
   int counted_bars = IndicatorCounted();
//---- checking for possible errors
   if(counted_bars < 0) 
       return(-1);
//---- the last bar will be recounted
   if(All_Bars < 1)
       All_Bars = Bars;
   if(counted_bars > 0 && Last_Bars > 0) 
       counted_bars -= Last_Bars;
   limit = All_Bars;

//---- IBFX Changes 

//   if (StringFind(Symbol(),"m") != -1)
   if (StringLen(Symbol()) == 7)
   {
     AddChar = StringSubstr(Symbol(), 6, 1);
     sAUDUSD  = "AUDUSD" + AddChar;
     sEURUSD  = "EURUSD" + AddChar;
     sUSDCHF  = "USDCHF" + AddChar;
     sNZDUSD  = "NZDUSD" + AddChar;
     sGBPUSD  = "GBPUSD" + AddChar;
     sUSDJPY  = "USDJPY" + AddChar;
     sUSDCAD  = "USDCAD" + AddChar;
   } 
   else 
   {
     sAUDUSD  = "AUDUSD";
     sEURUSD  = "EURUSD";
     sUSDCHF  = "USDCHF";
     sNZDUSD  = "NZDUSD";
     sGBPUSD  = "GBPUSD";
     sUSDJPY  = "USDJPY";
     sUSDCAD  = "USDCAD";    
   }  
   
//---- main cycle
   for(int i = 0; i < limit; i++)
     {
         GetOpenCloseCalcs(i);
         
     }//end block for(int i=0; i<limit; i++)
     
      PlotResults();
      
//----
   return(0);
  }

void GetOpenCloseCalcs(int i)
{
         if(EUR)
         {
           double EURUSD_1 = iClose(sEURUSD, 0, i+1);
           double EURUSD_2 = iClose(sEURUSD, 0, i+2);
           if(!EURUSD_1 || !EURUSD_2)
               return;
         }
       if(GBP)
         {
           double GBPUSD_1 = iClose(sGBPUSD, 0, i+1);
           double GBPUSD_2 = iClose(sGBPUSD, 0, i+2);
           if(!GBPUSD_1 || !GBPUSD_2)
               return;
         }
       if(AUD)
         {
           double AUDUSD_1 = iClose(sAUDUSD, 0, i+1);
           double AUDUSD_2 = iClose(sAUDUSD, 0, i+2);
           if(!AUDUSD_1 || !AUDUSD_2)
               return;
         }
       if(NZD)
         {
           double NZDUSD_1 = iClose(sNZDUSD, 0, i+1);
           double NZDUSD_2 = iClose(sNZDUSD, 0, i+2);
           if(!NZDUSD_1 || !NZDUSD_2)
               return;
         }
       if(CAD)
         {
           double USDCAD_1 = iClose(sUSDCAD, 0, i+1);
           double USDCAD_2 = iClose(sUSDCAD, 0, i+2);
           if(!USDCAD_1 || !USDCAD_2)
               return;
         }
       if(CHF)
         {
           double USDCHF_1 = iClose(sUSDCHF, 0, i+1);
           double USDCHF_2 = iClose(sUSDCHF, 0, i+2);
           if(!USDCHF_1 || !USDCHF_2)
               return;
         }
       if(JPY)
         {
           double USDJPY_1 = iClose(sUSDJPY, 0, i+1);
           double USDJPY_2 = iClose(sUSDJPY, 0, i+2);
           if(!USDJPY_1 || !USDJPY_2)
               return;
         }
       // calculation of currencies 
       if(USD)
         {
           arrUSD[i] = 0;
           if(EUR) 
               arrUSD[i] += EURUSD_2 / EURUSD_1 - 1;
           if(GBP) 
               arrUSD[i] += GBPUSD_2 / GBPUSD_1 - 1;
           if(AUD) 
               arrUSD[i] += AUDUSD_2 / AUDUSD_1 - 1;
           if(NZD) 
               arrUSD[i] += NZDUSD_2 / NZDUSD_1 - 1;
           if(CHF) 
               arrUSD[i] += USDCHF_1 / USDCHF_2 - 1;
           if(CAD) 
               arrUSD[i] += USDCAD_1 / USDCAD_2 - 1;
           if(JPY) 
               arrUSD[i] += USDJPY_1 / USDJPY_2 - 1;
         }// end if USD
       if(EUR)
         {
           arrEUR[i] = 0;
           if(USD) 
               arrEUR[i] += EURUSD_1 / EURUSD_2 - 1;
           if(GBP) 
               arrEUR[i] += (EURUSD_1 / GBPUSD_1) / 
                            (EURUSD_2/GBPUSD_2) - 1;
           if(AUD) 
               arrEUR[i] += (EURUSD_1 / AUDUSD_1) / 
                            (EURUSD_2/AUDUSD_2) - 1;
           if(NZD) 
               arrEUR[i] += (EURUSD_1 / NZDUSD_1) / 
                            (EURUSD_2/NZDUSD_2) - 1;
           if(CHF) 
               arrEUR[i] += (EURUSD_1*USDCHF_1) / 
                            (EURUSD_2*USDCHF_2) - 1;
           if(CAD) 
               arrEUR[i] += (EURUSD_1*USDCAD_1) / 
                            (EURUSD_2*USDCAD_2) - 1;
           if(JPY) 
               arrEUR[i] += (EURUSD_1*USDJPY_1) / 
                            (EURUSD_2*USDJPY_2) - 1;
         }// end if EUR
       if(GBP)
         {
           arrGBP[i] = 0;
           if(USD) 
               arrGBP[i] += GBPUSD_1 / GBPUSD_2 - 1;
           if(EUR) 
               arrGBP[i] += (EURUSD_2 / GBPUSD_2) / 
                            (EURUSD_1 / GBPUSD_1) - 1;
           if(AUD) 
               arrGBP[i] += (GBPUSD_1 / AUDUSD_1) / 
                            (GBPUSD_2 / AUDUSD_2) - 1;
           if(NZD) 
               arrGBP[i] += (GBPUSD_1 / NZDUSD_1) / 
                            (GBPUSD_2 / NZDUSD_2) - 1;
           if(CHF) 
               arrGBP[i] += (GBPUSD_1*USDCHF_1) / 
                            (GBPUSD_2*USDCHF_2) - 1;
           if(CAD) 
               arrGBP[i] += (GBPUSD_1*USDCAD_1) / 
                            (GBPUSD_2*USDCAD_2) - 1;
           if(JPY) 
               arrGBP[i] += (GBPUSD_1*USDJPY_1) / 
                            (GBPUSD_2*USDJPY_2) - 1;
          }// end if GBP
       if(AUD)
         {
           arrAUD[i] = 0;
           if(USD) 
               arrAUD[i] += AUDUSD_1 / AUDUSD_2 - 1;
           if(EUR) 
               arrAUD[i] += (EURUSD_2 / AUDUSD_2) / 
                            (EURUSD_1 / AUDUSD_1) - 1;
           if(GBP) 
               arrAUD[i] += (GBPUSD_2 / AUDUSD_2) / 
                            (GBPUSD_1 / AUDUSD_1) - 1;
           if(NZD) 
               arrAUD[i] += (AUDUSD_1/NZDUSD_1) / 
                            (AUDUSD_2 / NZDUSD_2) - 1;
           if(CHF) 
               arrAUD[i] += (AUDUSD_1*USDCHF_1) / 
                            (AUDUSD_2*USDCHF_2) - 1;
           if(CAD) 
               arrAUD[i] += (AUDUSD_1*USDCAD_1) / 
                            (AUDUSD_2*USDCAD_2) - 1;
           if(JPY) 
               arrAUD[i] += (AUDUSD_1*USDJPY_1) / 
                            (AUDUSD_2*USDJPY_2) - 1;
         }// end if AUD
       if(NZD)
         {
           arrNZD[i] = 0;
           if(USD) 
               arrNZD[i] += NZDUSD_1 / NZDUSD_2 - 1;
           if(EUR) 
               arrNZD[i] += (EURUSD_2 / NZDUSD_2) / 
                            (EURUSD_1/NZDUSD_1) - 1;
           if(GBP) 
               arrNZD[i] += (GBPUSD_2 / NZDUSD_2) / 
                            (GBPUSD_1 / NZDUSD_1) - 1;
           if(AUD) 
               arrNZD[i] += (AUDUSD_2 / NZDUSD_2) / 
                            (AUDUSD_1 / NZDUSD_1) - 1;
           if(CHF) 
               arrNZD[i] += (NZDUSD_1*USDCHF_1) / 
                            (NZDUSD_2*USDCHF_2) - 1;
           if(CAD) 
               arrNZD[i] += (NZDUSD_1*USDCAD_1) / 
                            (NZDUSD_2*USDCAD_2) - 1;
           if(JPY) 
               arrNZD[i] += (NZDUSD_1*USDJPY_1) / 
                            (NZDUSD_2*USDJPY_2) - 1;
         }// end if NZD
       if(CAD)
         {
           arrCAD[i] = 0;
           if(USD) 
               arrCAD[i] += USDCAD_2 / USDCAD_1 - 1;
           if(EUR) 
               arrCAD[i] += (EURUSD_2*USDCAD_2) / 
                            (EURUSD_1*USDCAD_1) - 1;
           if(GBP) 
               arrCAD[i] += (GBPUSD_2*USDCAD_2) / 
                            (GBPUSD_1*USDCAD_1) - 1;
           if(AUD) 
               arrCAD[i] += (AUDUSD_2*USDCAD_2) / 
                            (AUDUSD_1*USDCAD_1) - 1;
           if(NZD) 
               arrCAD[i] += (NZDUSD_2*USDCAD_2) / 
                            (NZDUSD_1*USDCAD_1) - 1;
           if(CHF) 
               arrCAD[i] += (USDCHF_1 / USDCAD_1) / 
                            (USDCHF_2 / USDCAD_2) - 1;
           if(JPY) 
               arrCAD[i] += (USDJPY_1 / USDCAD_1) / 
                            (USDJPY_2 / USDCAD_2) - 1;
         }// end if CAD
       if(CHF)
         {
           arrCHF[i] = 0;
           if(USD) 
               arrCHF[i] += USDCHF_2 / USDCHF_1 - 1;
           if(EUR) 
               arrCHF[i] += (EURUSD_2*USDCHF_2) / 
                            (EURUSD_1*USDCHF_1) - 1;
           if(GBP) 
               arrCHF[i] += (GBPUSD_2*USDCHF_2) / 
                            (GBPUSD_1*USDCHF_1) - 1;
           if(AUD) 
               arrCHF[i] += (AUDUSD_2*USDCHF_2) / 
                            (AUDUSD_1*USDCHF_1) - 1;
           if(NZD) 
               arrCHF[i] += (NZDUSD_2*USDCHF_2) / 
                            (NZDUSD_1*USDCHF_1) - 1;
           if(CAD) 
               arrCHF[i] += (USDCHF_2 / USDCAD_2) / 
                            (USDCHF_1 / USDCAD_1) - 1;
           if(JPY) 
               arrCHF[i] += (USDJPY_1 / USDCHF_1) / 
                            (USDJPY_2 / USDCHF_2) - 1;
         }// end if CHF
       if(JPY)
         {
           arrJPY[i] = 0;
           if(USD) 
               arrJPY[i] += USDJPY_2 / USDJPY_1 - 1;
           if(EUR) 
               arrJPY[i] += (EURUSD_2*USDJPY_2) / 
                            (EURUSD_1*USDJPY_1) - 1;
           if(GBP) 
               arrJPY[i] += (GBPUSD_2*USDJPY_2) / 
                            (GBPUSD_1*USDJPY_1) - 1;
           if(AUD) 
               arrJPY[i] += (AUDUSD_2*USDJPY_2) / 
                            (AUDUSD_1*USDJPY_1) - 1;
           if(NZD) 
               arrJPY[i] += (NZDUSD_2*USDJPY_2) / 
                            (NZDUSD_1*USDJPY_1) - 1;
           if(CAD) 
               arrJPY[i] += (USDJPY_2/USDCAD_2) / 
                            (USDJPY_1/USDCAD_1) - 1;
           if(CHF) 
               arrJPY[i] += (USDJPY_2/USDCHF_2) / 
                            (USDJPY_1/USDCHF_1) - 1;
         }// end if JPY
}



void PlotResults()
{

   int cur = Y_Top; 
//   int st = 23;      
   int st = Y_Step;      
   if(USD)
     {
       if (arrUSD[2]<arrUSD[1])  sl("USD", arrUSD[1], arrUSD[2], "SymbUSD","+", cur, Color_USD);
       if (arrUSD[2]>arrUSD[1])  sl("USD", arrUSD[1], arrUSD[2], "SymbUSD","-", cur, Color_USD);       
       if (arrUSD[2]==arrUSD[1]) sl("USD", arrUSD[1], arrUSD[2], "SymbUSD","=", cur, Color_USD);              
       cur += st;
     }
   if(EUR)
     {
       if (arrEUR[2]<arrEUR[1])  sl("EUR", arrEUR[1], arrEUR[2], "SymbEUR","+", cur, Color_EUR);
       if (arrEUR[2]>arrEUR[1])  sl("EUR", arrEUR[1], arrEUR[2], "SymbEUR","-", cur, Color_EUR);       
       if (arrEUR[2]==arrEUR[1]) sl("EUR", arrEUR[1], arrEUR[2], "SymbEUR","=", cur, Color_EUR);        
       cur += st;
     }
   if(GBP)
     {
       if (arrGBP[2]<arrGBP[1])  sl("GBP", arrGBP[1], arrGBP[2], "SymbGBP","+", cur, Color_GBP);
       if (arrGBP[2]>arrGBP[1])  sl("GBP", arrGBP[1], arrGBP[2], "SymbGBP","-", cur, Color_GBP);       
       if (arrGBP[2]==arrGBP[1]) sl("GBP", arrGBP[1], arrGBP[2], "SymbGBP","=", cur, Color_GBP);     
       cur += st;
     }
   if(CHF)
     {
       if (arrCHF[2]<arrCHF[1])  sl("CHF", arrCHF[1], arrCHF[2], "SymbCHF","+", cur, Color_CHF);
       if (arrCHF[2]>arrCHF[1])  sl("CHF", arrCHF[1], arrCHF[2], "SymbCHF","-", cur, Color_CHF);       
       if (arrCHF[2]==arrCHF[1]) sl("CHF", arrCHF[1], arrCHF[2], "SymbCHF","=", cur, Color_CHF); 
       cur += st;
     }
   if(AUD)
     {
       if (arrAUD[2]<arrAUD[1])  sl("AUD", arrAUD[1], arrAUD[2], "SymbAUD","+", cur, Color_AUD);
       if (arrAUD[2]>arrAUD[1])  sl("AUD", arrAUD[1], arrAUD[2], "SymbAUD","-", cur, Color_AUD);       
       if (arrAUD[2]==arrAUD[1]) sl("AUD", arrAUD[1], arrAUD[2], "SymbAUD","=", cur, Color_AUD); 
       cur += st;
     }
   if(CAD)
     {
       if (arrCAD[2]<arrCAD[1])  sl("CAD", arrCAD[1], arrCAD[2], "SymbCAD","+", cur, Color_CAD);
       if (arrCAD[2]>arrCAD[1])  sl("CAD", arrCAD[1], arrCAD[2], "SymbCAD","-", cur, Color_CAD);       
       if (arrCAD[2]==arrCAD[1]) sl("CAD", arrCAD[1], arrCAD[2], "SymbCAD","=", cur, Color_CAD); 
       cur += st;
     }
   if(JPY)
     {
       if (arrJPY[2]<arrJPY[1])  sl("JPY", arrJPY[1], arrJPY[2], "SymbJPY","+", cur, Color_JPY);
       if (arrJPY[2]>arrJPY[1])  sl("JPY", arrJPY[1], arrJPY[2], "SymbJPY","-", cur, Color_JPY);       
       if (arrJPY[2]==arrJPY[1]) sl("JPY", arrJPY[1], arrJPY[2], "SymbJPY","=", cur, Color_JPY);     
       cur += st;
     }
   if(NZD)
     {
       if (arrNZD[2]<arrNZD[1])  sl("NZD", arrNZD[1], arrNZD[2], "SymbNZD","+", cur, Color_NZD);
       if (arrNZD[2]>arrNZD[1])  sl("NZD", arrNZD[1], arrNZD[2], "SymbNZD","-", cur, Color_NZD);       
       if (arrNZD[2]==arrNZD[1]) sl("NZD", arrNZD[1], arrNZD[2], "SymbNZD","=", cur, Color_NZD);         
       cur += st;
     }     
}

//+------------------------------------------------------------------+
//|  Subroutines                                                     |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void sl(string currency, double val1, double val2, string IndicatoreName, string sym, int y, color col)
  {
   int window = WindowFind(Indicator_Name);
   string ID = Indicator_Name+Objs;
   string mIndicatoreName, disp;
   double diff;
   
   mIndicatoreName =  Indicator_ID + IndicatoreName;
   int tmp = 10 + y;
   Objs++;
   diff = val1 - val2;
   
//   disp = currency + " " + sym + "  " + DoubleToStr(diff*1000.0, 2);
   disp = currency + " " + sym + "  " + DoubleToStr(val1,4) + " : " + DoubleToStr(val2, 4) + " : " + DoubleToStr(diff, 4);
   if (ObjectFind(mIndicatoreName)==-1)
   {
    if(ObjectCreate(mIndicatoreName, OBJ_LABEL, window, 0, 0))
     {
       //ObjectDelete(ID);
       ObjectSet(mIndicatoreName, OBJPROP_XDISTANCE, 10);
       ObjectSet(mIndicatoreName, OBJPROP_YDISTANCE, y);
       ObjectSetText(mIndicatoreName, disp, TxtSize, "Arial Black", col);
     }   
   }
   else
   {
     ObjectSet(mIndicatoreName, OBJPROP_XDISTANCE, 10);
     ObjectSet(mIndicatoreName, OBJPROP_YDISTANCE, y);
     ObjectSetText(mIndicatoreName, disp, TxtSize, "Arial Black", col);        
   }
   
/*   if(ObjectCreate(ID, OBJ_LABEL, window, 0, 0))
     {
       //ObjectDelete(ID);
       ObjectSet(ID, OBJPROP_XDISTANCE, y + 35);
       ObjectSet(ID, OBJPROP_YDISTANCE, 10);
       ObjectSetText(ID, sym, 15, "Arial Black", col);
     }
*/     
  }   

//+------------------------------------------------------------------+

Similar scripts

CCFp_v1[1].0.2

This indicator calculates and visualizes the relative price velocity of major forex pairs by comparing weighted moving average deviations across a diversified currency basket.

CCFp_v1[1].0.2a

This indicator calculates the relative momentum of major fiat currencies by synthesizing moving average deviations across multiple currency pairs to visualize instantaneous directional strength.

CCFp_v1[1].0.3dvert

This indicator calculates and visualizes the relative price velocity of major currencies by aggregating the percentage change between specific currency pairs to identify leading market strengths.

CCFp_v1[1].0.3cvert

This indicator calculates and visualizes the relative strength and moving average deviations of major currency pairs to identify cross-market correlations.

CCFp_v1[1].0.2cvert

This indicator calculates and visualizes the relative strength differentials between major global currencies by comparing moving average ratios across a multi-pair synthetic matrix.

CCFp_v1[1].0.2bvert

This indicator calculates the relative strength and momentum of major global currencies by analyzing price velocity differentials across multiple currency pairs simultaneously.

CCFp_v1[1].0.2b

This indicator quantifies the interdependency of major forex pairs by calculating weighted relative strength movements across a diverse basket of currencies simultaneously.

DailyPercentageChange

RD-PivotLines

This indicator dynamically calculates and plots high-order technical levels including standard pivots, Fibonacci retracements, Camarilla range bounds, and midpoint clusters based on multi-timezone session data.

BarTimeCountDown

Heatmap_Gradient_Scale_vPTr

Comments