Attachments: Learn New MQL Coding

Learn New MQL Coding

#61
Mar 13, 2014 9:16am Mar 13, 2014 9:16am

Kiads
| Membership Revoked | Joined May 2012 | 1,218 Posts

Quoting broketrader

Disliked

{quote} Ok, Give me some time to have a look for a solution. I will be back asap to start and go step by step.

Ignored

Thank You Sir, really appreciate that, and take your time Sir, I will patiently wait to learn..
Best Regard.
MTH

#62
Mar 13, 2014 1:01pm Mar 13, 2014 1:01pm

FinGeR
| Joined Nov 2005 | Status: Trader | 57 Posts

Thank you.

#63
Mar 14, 2014 9:19am Mar 14, 2014 9:19am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Hi all,

I'm finalizing my Renko chart indicator and will go through its implementation very soon but before that, I would like to take the opportunity to introduce you to design patterns.

In short, a design pattern is a way to solve a recurrent problem in a single manner or by a single kind of design and this fits perfectly to OOP.

There are varieties of well known design patterns, some more complicated than others, and I will not talk about all of them but just about the most popular which is the singleton.

In OOP, there are objects that need to live milliseconds, some others a bit longer and some that need to live during the entire life of the application. Very often those objects need also to by accessed from anywhere in the application at any moment and this is when the singleton pattern comes into play.

A singleton object owns a pointer to itself, and knows if he has been instantiated (created) or not yet.

Only two components need to be added to any class to integrate to it the singleton pattern.

The first component is a pointer to itself which needs to be static as there is only one object of this type.

Here is a class with a pointer to itself.

Inserted Code

class MyClass {
   static MyClass* m_pInstance;
};

Note that the m_pInstance member will need to be explicitly initialized to NULL. So after the class declaration, we need add the following initialization code:

Inserted Code

MyClass* MyClass::m_pInstance = NULL;

This effectively initializes once and for all, the m_pInstance member of MyClass when the application is loaded, or in our case, when the indicator is loaded.

At this point, this member is not accessible as he's private, that's why we need the second component which is a static method that will be in charge of automatically creating the object and returning a pointer to it.

Here is the class declaration again. The GetId() method is for illustration purposes only:

Inserted Code

class MyClass {
   static MyClass* m_pInstance;
  
   public:
      int               GetId(){ return 5; }
      static MyClass*   Instance();
};

And its implementation:

Inserted Code

MyClass* MyClass::Instance() {
   if( m_pInstance == NULL ){
      m_pInstance = new MyClass();
   }
   return m_pInstance;
}

By having singletons implemented in your programs, you don't need any more global variables to have access to them.
At any time in your code, just make usage of them as shown below :

Inserted Code

MyClass::Instance().GetId();

This is right but there is still a flaw in our class as nothing prevents us to declare another object of the same type anywhere in our application:

Inserted Code

MyClass a;

This is actually perfectly legal but it's not what we want and could result in some unexpected behavior in our application. So we need a way to prevent the programmer to declare duplicate objects.

We do that just by adding a private constructor even if it's empty. A private constructor means that the class can only be instantiated within its scope. And that's exactly what the method Instance() does. Instance() is in the scope of MyClass as it's a member of it.

Our class declaration again :

Inserted Code

class MyClass {
   static MyClass* m_pInstance;
    
      MyClass(){} // private constructor.
  
   public:
      int               GetId(){ return 5; }
      static MyClass*   Instance();
};

Now, making a declaration like :

Inserted Code

MyClass a;

Would result in a compilation error as the default constructor of the class MyClass is private and not externally accessible.

You can see that the singleton implementation fits perfectly for our Renko chart indicator as we can only have one Renko chart in our indicator.

♦ ♦ ♦

Simplicity is the Ultimate Sophistication.

#64
Mar 18, 2014 4:02am Mar 18, 2014 4:02am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Here we go with our Renko Chart indicator.

I hope that some of you will have some interest and will enjoy going through its implementation. I will try to keep the posts short and go step by step so you can easy follow and understand what I'm doing. If you get in trouble, don't hesitate to ask.

Let's begin,

To make things simple, we will write a class named RenkoChart, it will be a singleton meaning that only one object of its type can be instantiated (created) per indicator as it has no sense to have multiple Renko charts per chart.

The tasks of our Renko class will be:

Initialize its internal variables from user input. They mainly are: The Renko brick size and the custom time frame on which we will write the Renko bars.
.
Create and compute a Renko custom period history file from an original 1 min history file.
.
Update that history file from live feed and actualize the corresponding chart that will be opened as an offline chart. This will make it behave like a live chart.
.

Let's declare our RenkoChart singleton class:

Inserted Code

class RenkoChart {
 
   static RenkoChart*      m_pInstance;
  
   protected:
                           RenkoChart();
 
   public:
      static RenkoChart*   Instance();
  
};

And here is it implementation :

Inserted Code

RenkoChart* RenkoChart::m_pInstance = NULL;
 
RenkoChart::RenkoChart() {
}
 
static RenkoChart* RenkoChart::Instance() {
   if( m_pInstance == NULL ){
      m_pInstance = new RenkoChart();
   }
   return m_pInstance;
}

Nothing new here, this is the standard singleton pattern you saw on my previous post.

Attached is its implementation file. I have named it RenckoChartSbS.mqh where SbS stands for Step by Step.
Download and copy it to your include folder, we will incrementally grow this file as we progress.

I will talk about the indicator file on next post.

Attached File(s)

RenkoChartSbS.mqh 2 KB | 506 downloads

Simplicity is the Ultimate Sophistication.

#65
Mar 18, 2014 4:17am Mar 18, 2014 4:17am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Attached is the RenkoChart indicator file RenkoChartSbS.mq4

It's an empty indicator file with a single input parameter for now which is the (Renko) brick size.

Download and copy it to your Indicators folder. Verify that it compiles correctly as this file includes the RenkoChartSbs.mqh include file from the previous post.

Attached File(s)

RenkoChartSbS.mq4 3 KB | 499 downloads

Simplicity is the Ultimate Sophistication.

#66
Mar 18, 2014 5:45am Mar 18, 2014 5:45am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Let's start writing some initialization code for our RenkoChart object.

As this initialization code will be called from the OnInit() function in the indicator file, I find logical to create a method inside our RenkoChart called also OnInit(). This method will accept as parameters the Renko brick size and also the custom period on which we will write the history file.

Here is how it must be declared inside the class, under the 'public' accessor.

Inserted Code

bool                 OnInit( int custperiod, int boxsizepips );

Off course, we will need to store those input parameters. To do so, we declare two members inside our class. These members will be private.

Please, update your class declaration as below:

Inserted Code

class RenkoChart {
 
   static RenkoChart*      m_pInstance;
   int                     m_CustomPeriod;   // new member
   int                     m_BoxSize;        // new member
  
   protected:
                           RenkoChart();
 
   public:
      static RenkoChart*   Instance();
      bool                 OnInit( int custperiod, int boxsizepips ); // new method
  
};

Here is our OnInit implementation:

Inserted Code

bool RenkoChart::OnInit( int custperiod, int boxsizepips ) {
   m_BoxSize = boxsizepips;
   m_CustomPeriod = custperiod;
}

Remember on point 2 we said we must create a new Renko history file from 1 min history but we will do it instead from the current bars in chart, this could be a bit more efficient than reading and writing a file, and if you have sufficient bars in your chart, we could effectively get all the history without opening and handling the file. So the only thing that's left to do is to create the Renko history file, compute the Renko bars from our chart bars, and write them into the file. Simple.

Here is the code to create our new Renko history file inside our OnInit() method:

Inserted Code

bool RenkoChart::OnInit( int custperiod, int boxsizepips ) {
   m_BoxSize = boxsizepips;
   m_CustomPeriod = custperiod;
   string CustomPeriodStr = IntegerToString( m_CustomPeriod );
  
   // Create history file
   m_FileHandle = FileOpenHistory( Symbol() + CustomPeriodStr + ".hst", FILE_BIN|FILE_WRITE );
 
   if( m_FileHandle < 0 ) {
      Print( "Error creating history file: " + IntegerToString(GetLastError()) );
      return false;
   }
}

Now that we have the file to work with and before starting writing the Renko bars to it, we must insert some MQL header at its beginning.

We will also need to store the bar count which is the number of bars in the chart, the bar index which is the bar index that we are currently looking at for our Renko bar calculation and the handle of our new history file.

Here is the code.

Inserted Code

bool RenkoChart::OnInit( int custperiod, int boxsizepips ) {
   m_BoxSize = boxsizepips;
   m_CustomPeriod = custperiod;
 
   string CustomPeriodStr = IntegerToString( m_CustomPeriod );
  
   // Create history file
   m_FileHandle = FileOpenHistory( Symbol() + CustomPeriodStr + ".hst", FILE_BIN|FILE_WRITE );
  
   if( m_FileHandle < 0 ) {
      Print( "Error creating history file: " + IntegerToString(GetLastError()) );
      return false;
   }
 
   // Get number of bars in chart and initialize index
   m_BarCount = Bars;
   m_BarIndex = m_BarCount-1;
 
    // Write file header.
   int      Version     = 400;
   string   CopyRight   = "(c) 2014 Broketrader RenkoChart";
   string   SymbolPair  = Symbol();
   int      TimePeriod  = m_CustomPeriod;
   int      PriceDigits = Digits;
   int      Unused[13];
  
   ArrayInitialize( Unused, 0 );
  
   FileWriteInteger( m_FileHandle, Version, LONG_VALUE );      // Version
   FileWriteString( m_FileHandle, CopyRight, 64 );             // Copyright
   FileWriteString( m_FileHandle, SymbolPair, 12 );            // Symbol
   FileWriteInteger( m_FileHandle, TimePeriod, LONG_VALUE );   // Period
   FileWriteInteger( m_FileHandle, PriceDigits, LONG_VALUE );  // Digits
   FileWriteInteger( m_FileHandle, 0, LONG_VALUE );            // Time Sign
   FileWriteInteger( m_FileHandle, 0, LONG_VALUE );            // Last Sync
   FileWriteArray( m_FileHandle, Unused, 0, 13 );              // Unused
 
   return true;
 }

And here is the class declaration again with the new members :

Inserted Code

class RenkoChart {
 
   static RenkoChart*      m_pInstance;
   int                     m_CustomPeriod;  
   int                     m_BoxSize;      
   int                     m_FileHandle;  // new member
   int                     m_BarCount;    // new member
   int                     m_BarIndex;    // new member
  
   protected:
                           RenkoChart();
 
   public:
      static RenkoChart*   Instance();
      bool                 OnInit( int custperiod, int boxsizepips );
  
};

At this point, we are ready to write our first Renko bar and initialize some working variables (Previous high/low) data for the following bars.

For this first bar, I have done things simple, I just calculate a bar from the low to the high which is bull if close is greater than open or bear otherwise.

To store the Renko rates (open, high, low, etc values), I have declared a structure and a variable of its type 'm_Rate' which is more convenient.

Again, the new OnInit() method :

Inserted Code

bool RenkoChart::OnInit( int custperiod, int boxsizepips ) {
   m_BoxSize = boxsizepips;
   m_CustomPeriod = custperiod;
 
   string CustomPeriodStr = IntegerToString( m_CustomPeriod );
  
   // Create history file
   m_FileHandle = FileOpenHistory( Symbol() + CustomPeriodStr + ".hst", FILE_BIN|FILE_WRITE );
  
   if( m_FileHandle < 0 ) {
      Print( "Error creating history file: " + IntegerToString(GetLastError()) );
      return false;
   }
 
   // Get number of bars in chart and initialize index
   m_BarCount = Bars;
   m_BarIndex = m_BarCount-1;
 
    // Write file header.
   int      Version     = 400;
   string   CopyRight   = "(c) 2014 Broketrader RenkoChart";
   string   SymbolPair  = Symbol();
   int      TimePeriod  = m_CustomPeriod;
   int      PriceDigits = Digits;
   int      Unused[13];
  
   ArrayInitialize( Unused, 0 );
  
   FileWriteInteger( m_FileHandle, Version, LONG_VALUE );      // Version
   FileWriteString( m_FileHandle, CopyRight, 64 );             // Copyright
   FileWriteString( m_FileHandle, SymbolPair, 12 );            // Symbol
   FileWriteInteger( m_FileHandle, TimePeriod, LONG_VALUE );   // Period
   FileWriteInteger( m_FileHandle, PriceDigits, LONG_VALUE );  // Digits
   FileWriteInteger( m_FileHandle, 0, LONG_VALUE );            // Time Sign
   FileWriteInteger( m_FileHandle, 0, LONG_VALUE );            // Last Sync
   FileWriteArray( m_FileHandle, Unused, 0, 13 );              // Unused
 
   // Write first simple bar.
   if( Close[m_BarIndex] > Open[m_BarIndex] ){
      m_Rate.m_Open    = Low[m_BarIndex];
      m_Rate.m_Low     = m_Rate.m_Open;
      m_Rate.m_High    = High[m_BarIndex];
      m_Rate.m_Close   = m_Rate.m_High;
   }
   else{
      m_Rate.m_Open    = High[m_BarIndex];
      m_Rate.m_High    = m_Rate.m_Open;
      m_Rate.m_Low     = Low[m_BarIndex];
      m_Rate.m_Close   = m_Rate.m_Low;
   }
  
   m_PrevHigh = m_Rate.m_High;
   m_PrevLow  = m_Rate.m_Low;
  
   m_Rate.m_Vol  = (double)Volume[m_BarIndex];
   m_Rate.m_Time =  (int)Time[m_BarIndex];
   FileWriteStruct( m_FileHandle, m_Rate );
  
   // We prepare for the next bar
   m_BarIndex--;
   m_Rate.m_Vol = 0;
 
   return true;
 }

And the class declaration with the new members :

Inserted Code

class RenkoChart {
 
   struct   RenkoRate{
      int      m_Time;
      double   m_Open, m_Low, m_High, m_Close, m_Vol;
   }; // Private structure
 
   static RenkoChart*      m_pInstance;
   int                     m_CustomPeriod;  
   int                     m_BoxSize;      
   int                     m_FileHandle;  
   int                     m_BarCount;    
   int                     m_BarIndex;    
   RenkoRate               m_Rate;        // new member
   double                  m_PrevHigh;    // new member
   double                  m_PrevLow;     // new member
 
  
   protected:
                           RenkoChart();
 
   public:
      static RenkoChart*   Instance();
      bool                 OnInit( int custperiod, int boxsizepips );
  
};

We are done with the initialization code.

We are done with the initializing code.

We still need to call our OnInit method from our OnInit function in our indicator :

Here is our new OnInit indicator function :

Inserted Code

int OnInit() {
   if( ! RenkoChart::Instance().OnInit( 3, BoxSize ) ){
      return INIT_FAILED;
   }
   return INIT_SUCCEEDED;
}

Don't be confused about functions and methods having the same name and take care about the wording. A function is outside a class, a method is inside of it.

Let's see on next post how we write the remaining bars without blocking the terminal and while at the same time we display some info about the process…
.
.

Attached File(s)

RenkoChartSbS.mq4 3 KB | 443 downloads

RenkoChartSbS.mqh 6 KB | 397 downloads

Simplicity is the Ultimate Sophistication.

#67
Mar 18, 2014 7:52am Mar 18, 2014 7:52am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Now, our RenkoChart object was created and initialized, remember our call:

Inserted Code

RenkoChart::Instance().OnInit( 3, BoxSize )

At this point, our object has created a new history file with the custom period 3 (3 minutes), has written the file header and the first bar data.

Off course, we could just have written the remaining bars on the same call, but this would have blocked the terminal for an unspecified time without giving a chance to the user about what's was happening.

This is why I have preferred to do the job using the timer. I would have preferred to write a separate thread but such a feature doesn't exists in MQL, so I have utilized the timer to simulate a separate thread. This allows for non blocking the terminal and also updating live about our progress in writing the history file.

Let's start,

At the end of the initialization code, before the return statement, we add the following line.

Inserted Code

bool RenkoChart::OnInit( int custperiod, int boxsizepips ) {
.
.
.
   // Initiates event driven writing
   EventSetMillisecondTimer( 1 );
 
   return true;
 }

This will have as effect that the OnTimer function in our indicator file will be called almost immediately (after 1 millisecond).

Then from that OnTimer function we only need to call the equivalent method inside our class. The OnTimer method within our class will rearm the timer as many times as needed to complete our Renko history file. We will see that later.

Inserted Code

void OnTimer() {
   RenkoChart::Instance().OnTimer();
}

And off course implement our OnTimer method as illustrated step by step below.

First we need to kill the timer itself otherwise we have some risk on reentrancy :

Inserted Code

   // Avoid re-entrancy
   EventKillTimer();

Then we arbitrary decide how many bars we compute on each call and we do it using a double limited loop.

Inserted Code

   // Compute let's say a maximum of 100000 bars at a time.
   for( int i=0; i<100000 && m_BarIndex >= 1; i++, m_BarIndex-- ){
      bool NewBar = ComputeRenkoBar( m_BarIndex );
    
      if( NewBar ){
         FileWriteStruct( m_FileHandle, m_Rate );
         // Reset volume for next bar
         m_Rate.m_Vol = 0;
      }
   }

The first counter 'i' limits to a maximum of 100000 bars, the second counter 'm_BarIndex' avoids computing more bars than in the chart.

The ComputeRenkoBar method is in charge of calculating the Renko bar and telling by its return value if there was one or not. We will talk about it later.

On each call, we have to check if we have computed all the bars in the chart and close the file or rearm the timer and continue. This is done with the code below:

Inserted Code

   // If we have calculated all bars except the current one...
   if( m_BarIndex <= 1 ){
      // Finished. Display some termination info and don't rearm the timer anymore.
      Comment( "Renko Chart Completed. Please open the M3 offline chart" );
      // Store file position for further usage
      m_FileCPos = FileTell( m_FileHandle );
      // Close and we are done.
      FileClose( m_FileHandle );
      m_FileHandle = -1;
      m_InitDone = true;
   }
   else{
      // Not finished yet. Display some info text and rearm the timer
      double Completed = (double)(m_BarCount-m_BarIndex) / (double)m_BarCount * 100;
      Comment( "RenkoChart is creating the history file : " + DoubleToStr(Completed,0) + "% Completed" );
      EventSetMillisecondTimer( 1 );
   }

You see that each time the method is called, we check the value of m_BarIndex against 1 which corresponds to the last closed 1 min bar.

We do not want to compute the current bar at index 0, we will do that later.

Finally, here is the complete OnTimer method:

Inserted Code

void RenkoChart::OnTimer() {
   // Avoid re-entrancy
   EventKillTimer();
  
   // Compute let's say a maximum of 100000 bars at a time.
   for( int i=0; i<100000 && m_BarIndex >= 1; i++, m_BarIndex-- ){
      bool NewBar = ComputeRenkoBar( m_BarIndex );
    
      if( NewBar ){
         FileWriteStruct( m_FileHandle, m_Rate );
         // Reset volume for next bar
         m_Rate.m_Vol = 0;
      }
   }
  
   // If we have calculated all bars except the current one...
   if( m_BarIndex <= 1 ){
      // Finished. Display some termination info and don't rearm the timer anymore.
      Comment( "Renko Chart Completed. Please open the M3 offline chart" );
      // Store file position for further usage
      m_FileCPos = FileTell( m_FileHandle );
      // Close and we are done.
      FileClose( m_FileHandle );
      m_FileHandle = -1;
      m_InitDone = true;
   }
   else{
      // Not finished yet. Display some info text and rearm the timer
      double Completed = (double)(m_BarCount-m_BarIndex) / (double)m_BarCount * 100;
      Comment( "RenkoChart is creating the history file : " + DoubleToStr(Completed,0) + "% Completed" );
      EventSetMillisecondTimer( 1 );
   }
}

A Renko bar is drawn when the price is higher or lower the high or low of the previous Renko bar plus or minus the size of the Renko brick.

That's exactly what calculates the ComputeRenkoBar method below :

Inserted Code

bool RenkoChart::ComputeRenkoBar( int index ) {
   bool Res = false;
  
   if( Close[index] > m_PrevHigh + m_BoxSize*Point ) {
      m_Rate.m_Open    = m_PrevHigh;
      m_Rate.m_Low     = m_Rate.m_Open;
      m_Rate.m_High    = m_Rate.m_Open + m_BoxSize*Point;
      m_Rate.m_Close   = m_Rate.m_High;
      Res = true;
   }
   else if( Close[index] < m_PrevLow - m_BoxSize*Point ) {
      m_Rate.m_Open    = m_PrevLow;
      m_Rate.m_High    = m_Rate.m_Open;
      m_Rate.m_Low     = m_Rate.m_Open - m_BoxSize*Point;
      m_Rate.m_Close   = m_Rate.m_Low;
      Res = true;
   }
   if( m_Rate.m_Vol == 0 ){
      m_Rate.m_Vol = (double)Volume[m_BarIndex];
   }
   else{
      m_Rate.m_Vol += (double)Volume[m_BarIndex];
   }
  
   if( Res ){
      m_Rate.m_Time = (int)Time[index];
      m_PrevHigh = m_Rate.m_High;
      m_PrevLow  = m_Rate.m_Low;
   }
  
   return Res;
}

When the conditions are met to draw a bar, the corresponding values are stored in the 'm_Rate' structure variable and we return true.
Note that we take care also about the volume even if it's not used in Renko charts.

At this point, our history (3 min) file is filled with renko bars computed from our current 1 min chart. Opening the 3 min offline chart shows the result:

Attached Image (click to enlarge)

Click to Enlarge

Name: Screenshot1.png
Size: 20 KB

Our RenkoChart object is also ready to update it from the live feed. We will see that on next posts...

Attached File(s)

RenkoChartSbS.mqh 9 KB | 442 downloads

RenkoChartSbS.mq4 3 KB | 465 downloads

Simplicity is the Ultimate Sophistication.

#68
Mar 18, 2014 8:39am Mar 18, 2014 8:39am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Final step.

Updating our history file and the offline chart like a live chart.

The last method that we will need to write will be called from the OnCalculate function from our indicator, thus it will be called OnCalculate()

This method will be in charge of calculating the bars present in chart and not yet computed to the history file and also display the current price of the not yet completed bar.

Here is how to declare it inside our class :

Inserted Code

void                 OnCalculate( int bars );

How to call it from our indicator :

Inserted Code

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[])
{
   RenkoChart::Instance().OnCalculate( Bars );
   return(rates_total);
}

And finally, its implementation.

Inserted Code

void RenkoChart::OnCalculate( int bars ) {
  
   // We are still writing the histor file. Do nothing.
   if( ! m_InitDone ){
      return;
   }
  
   // On first call after history file creation, we must reopen the file
   if( m_FileHandle == -1 ){
      string CustomPeriodStr = IntegerToString( m_CustomPeriod );
      m_FileHandle = FileOpenHistory( Symbol() + CustomPeriodStr + ".hst", FILE_BIN|FILE_WRITE|FILE_READ|FILE_SHARE_READ|FILE_SHARE_WRITE );
      if( m_FileHandle == -1 ){
         Comment( "RenkoChart cannot update history file !" );
         return;
      }
   }
  
   // For all bars in chart that we have not yet computed...
   for( m_BarIndex=bars-m_BarCount; m_BarIndex >= 0; m_BarIndex-- ){
    
      if( m_BarIndex == 0 ){
         // Update current bar and keep file pos;
         // We rewrite last Renko bar values at the same file position
         ComputeCurrentBar();        
         FileSeek( m_FileHandle, m_FileCPos, SEEK_SET );
         FileWriteStruct( m_FileHandle, m_Rate );
         FileFlush( m_FileHandle );
      }
      else{
         // Look wether a new bar can be drawn (stored)
         bool NewBar = ComputeRenkoBar( m_BarIndex );
         if( NewBar ){
            FileSeek( m_FileHandle, m_FileCPos, SEEK_SET );
            FileWriteStruct( m_FileHandle, m_Rate );
            // Reset volume for next bar
            m_Rate.m_Vol = 0;
            FileFlush( m_FileHandle );
            m_FileCPos = FileTell( m_FileHandle );
         }
        
      }
   }
   // Call extern functions to force chart redraw
   UpdateChartWindow( m_CustomPeriod );
   m_BarCount = bars;
}

I will not go to explain it in detail as it does almost the same thing that the OnTimer method, but only for not computed bars of the chart.

The only particularity is that it has to take care of the position of the last structure in the file in order to write the values of last bar into it.

It calls also ComputeCurrentBar(), which you will find in the attached source file, instead of ComputeRenkoBar() That's because I decided to show the current bar my own way, I let you discover…

There is also another function call UpdateChartWindow which I got from another Renko Indi posted here. It's needed to force the update on the offline chart. I don't know who's the author of that code otherwise I would have mentioned it. Anyway, thanks to him/her.

Attached you will find the final files that you could use as base for your own Renko chart indicator, you are free to share, modify, improve etc.

Until the next...
.

Attached File(s)

RenkoChartSbS.mq4 3 KB | 539 downloads

RenkoChartSbS.mqh 14 KB | 528 downloads

Simplicity is the Ultimate Sophistication.

#69
Mar 19, 2014 4:29am Mar 19, 2014 4:29am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Another custom chart - Tick Chart (Tick Recorder)

I thought it could be interesting to create a Tick Chart starting from our Renko Chart indicator code.

It was easy, here it is.

Attached Image (click to enlarge)

Click to Enlarge

Name: Screenshot1.png
Size: 14 KB

Attached File(s)

TickChart.mq4 3 KB | 538 downloads

TickChart.mqh 7 KB | 572 downloads

Simplicity is the Ultimate Sophistication.

#70
Mar 19, 2014 6:35am Mar 19, 2014 6:35am

lucklogic
| Joined Sep 2011 | Status: Trader | 162 Posts

WOW ..............Thank you for sharing

#71
Mar 19, 2014 6:57am Mar 19, 2014 6:57am

Kiads
| Membership Revoked | Joined May 2012 | 1,218 Posts

Quoting broketrader

Disliked

Attached you will find the final files that you could use as base for your own Renko chart indicator, you are free to share, modify, improve etc. Until the next... . {file} {file}

Ignored

Thank You so much for your detail explanation.., really fantastic, I learn a lot of thing from your examples and explanations.
Really appreciate your dedicated time and caring for all of us..

May God Bless You and Your Family Forever.. Sir

MTH

#72
Mar 21, 2014 3:46am Mar 21, 2014 3:46am

lucklogic
| Joined Sep 2011 | Status: Trader | 162 Posts

I was wondering if you would be interested to guide us in the development of a basket creation indicator.

Seller9 runs a successful forum thread : Basket Trading EA

however he cchooses not to share his code, which is his prerogative.

He did share this general method but this is for build < 600 and is not compatible with current builds

If you where interested to guide us in the first principles creation of such an indicator, in the same manner as the Renko creation that would be fantastic

Seller9 "For those wondering how the basket chart is created, you can look over the following code in this indicator, they all use the same idea."

Attached File
http://assets.forexfactory.net/images/attach/mq4.gif Basketv8.mq4 10 KB | 145 downloads

Thanks in advance

#73
Mar 21, 2014 5:21am Mar 21, 2014 5:21am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Hi lucklogic,

Yes I could be interested but before taking my decision, could you or anyone else, please, explain in plain English what a basket indicator is.

What are the general principles or trading ideas behind such indicator.

You know, I could go through that entire thread "Baskest Trading EA" and try to understand but I don't have really the time to do so.

If we start, I think that it will save us time to firstly write down a kind or "Requirements" to clearly state what we want that indicator to be.
With that in hand, it will be much easier to go through and for everyone that comes by, to understand.

Thanks.

Simplicity is the Ultimate Sophistication.

#74
Mar 21, 2014 10:24am Mar 21, 2014 10:24am

lucklogic
| Joined Sep 2011 | Status: Trader | 162 Posts

A Basket indicator (like Seller9's) creates the different baskets as an off line chart, that can then be traded as if if was a normal pair via an EA

Basket trading takes a number of pairs (this can be any number but 5 or 14 is common) and simultaneous trades them in one direction.

So it is possible to create all manner of basket trades

See my example of a live chart that I have running now. This is a so called Core 5 basket, the off line chart is mimicking the underlying pairs movement so that they can be all traded as if if was a single pair

Basket trading is very flexible and multiplies the trading effect (both for Winning and Losing)

I'm seeking your help with the basket creation process up to it being displayed as an off line chart

Attached Image (click to enlarge)

Click to Enlarge

Name: Basket.PNG
Size: 33 KB

#75
Mar 21, 2014 11:05am Mar 21, 2014 11:05am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Hmm sorry, but still not clear to me.

Lets say that I want to create a basket of 2 pairs (don't know if this is possible) of EURUSD and USDCHF

1. Can you, or someone, explain to me how do you combine the prices of these two pairs to create the resulting price in an offline chart ?

1. If you buy or sell on that chart, you buy or sell all the pairs, right ?

Simplicity is the Ultimate Sophistication.

#76
Mar 21, 2014 11:38am Mar 21, 2014 11:38am

lucklogic
| Joined Sep 2011 | Status: Trader | 162 Posts

That's why you need the starter file that I provided Basketv8.mq4 Its all in their

And Yes if you then Buy or Sell on the Offline Chart you trade all of the pairs within that chart ( eg 5 pairs then 5 * buy or 5 * sell trades one for each pair)

Attached File(s)

Basketv8.mq4 10 KB | 503 downloads

#77
Mar 23, 2014 5:20am Mar 23, 2014 5:20am

Hukkleberry
| Joined Jun 2013 | Status: Trader | 37 Posts

broketrader

Glad to see this thread and thanks for your efforts. I first got the MT4 platform only in December and set about learning MQL4 and by the end of February had a pretty sound grasp. And then MT4 transitioned to Build 600+ and the code upgraded to MQL5 language and I had to start again! Since then I've been learning some C++ and looking at material from the MQL5 reference site and have just last week started coding again. Haven't put any of the OOP into practice yet and so seeing examples here is helpful.

Looking forward to seeing this thread continue teaching the principles of MQL5 OOP with examples (and not get highjacked by people looking for their specific requests to be coded). Appreciate the effort.

Huk

#78
Mar 23, 2014 5:48am Mar 23, 2014 5:48am

Halley
| Joined Oct 2013 | Status: Trader | 253 Posts

Quoting Hukkleberry

Disliked

...(and not get highjacked by people looking for their specific requests to be coded). Appreciate the effort. Huk

Ignored

That is what came to my mind as well. No queries about OOP but rather coding requests.

#79
Mar 23, 2014 6:53am Mar 23, 2014 6:53am

iwjw
| Joined Mar 2011 | Status: Trader | 464 Posts

Hi broketrader,
thanks for your hard work and the examples
could you add a destructor to the renko chart because the object stays alive after removing the indicator (memory leak message in expert tab)

#80
Mar 24, 2014 3:31am Mar 24, 2014 3:31am

broketrader
Joined Oct 2012 | Status: Trader | 1,696 Posts

Quoting lucklogic

Disliked

That's why you need the starter file that I provided Basketv8.mq4 Its all in their And Yes if you then Buy or Sell on the Offline Chart you trade all of the pairs within that chart ( eg 5 pairs then 5 * buy or 5 * sell trades one for each pair) {file}

Ignored

Lucklogic,

No problem in asking for some indicator example to illustrate how we could write it in OOP. I have even proposed that in one of my earlier post.

But, you have to consider that when making such proposal, you cannot just say, I got this code, just look into it. You are just asking for some code to be translated and this is not the purpose of this thread.

Personally, I can accept any query from anybody and make the translation into code but you have to know also that this requires some effort and time also from me, so I think that it's fair to ask people to provide the general idea and even some mathematical formula that needs to be programmed not just some old code that needs to be translated.

This is even necessary to later verify that the obtained results are in line with the indicator idea or formulas.
I hope that you understand my point.

Quoting Hukkleberry

Disliked

broketrader Glad to see this thread and thanks for your efforts. …

Ignored

Hi Huk.
Thank you, nice to have you on board.

Simplicity is the Ultimate Sophistication.

Platform Tech
/
Learn New MQL Coding
Reply to Thread
- 1 2 3 Page 4 5 6 17
- 1 3 Page 4 5 17

0 traders viewing now

Options

Similar Threads

Learn New MQL Coding