Posts made by fxDreema

I think it's needed. This is basic feature on all apps and it will be available for fxdreema too. I think these days. Now I'm on 1/3 of the work for this.

I forgot one code comment in wrong place while correcting the previous bug
Thanks for the bug report again!

I found the origin of this bug and it will be removed. Thanks for reporting!

Haha... okay. I have bad internet connection also

Done! Now when loading http://fxdreema.com/generator the last project state will be loaded with Actions History available.

First of all, check MQL4 (MQL5) specifications about special functions:
http://docs.mql4.com/basis/functions/special
http://www.mql5.com/en/docs/runtime/running

Let's take MQL4 for example. There are 3 basic special functions: Init(), Start() and DeInit(). The basic structure of MQL4 expert advisor looks like this:

//+------------------------------------------------------------------+
//|                                                     MQL4file.mq4 |
//|                      Copyright © 2011, MetaQuotes Software Corp. |
//|                                      "http://www.metaquotes.net" |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+

As you can see the three special functions are placed one after another.
Init() is called only once when expert advisor starts, Start() is called at each tick, and DeInit is called only once when you shut down the expert advisor.

In FXDreema each library (block) is represented in output code with it's own function.

• Not connected blocks will not appear in output code
• First blocks in logic trees will be called first
• Logic trees can be as many as you want
• Logic trees may be as bigger as you need
• One independend logic tree may have more than one first blocks

Let's see some examples. First we'll see what happens with only one logic tree.
http://i41.tinypic.com/1z4fi50.png
This will output something like this

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT INITIALIZATION SECTOR                                          |//
	//| Runs only once when expert loads                                      |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int init()
	{

		return(0);
	}
  

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT START SECTOR                                                   |//
	//| Runs at every new tick (begins with "start()" function)               |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int start()
	{
		start1(); // The only first block in the only logic tree
		return(0);
	}

	//////////////////////////////////
	// Define block 1 (Empty block) //
	void start1()
	{
		start2(); start4();
	}

	//////////////////////////////////
	// Define block 2 (Empty block) //
	void start2()
	{
		start3();
	}

	//////////////////////////////////
	// Define block 3 (Empty block) //
	void start3()
	{
		/* Nothing here */
	}

	//////////////////////////////////
	// Define block 4 (Empty block) //
	void start4()
	{
		/* Nothing here */
	}

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT DEINITIALIZATION SECTOR                                        |//
	//| Runs only once when expert unloads                                    |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int deinit()
	{
		return(0);
	}

The logic is:
At each tick block 1 is runned
If block 1 passes -> Run block 2 and block 4
If block 2 passes -> Run block 3

Ok, there's two logic trees:
http://i41.tinypic.com/zunnl4.png
And the output code is:

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT INITIALIZATION SECTOR                                          |//
	//| Runs only once when expert loads                                      |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int init()
	{

		return(0);
	}
  

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT START SECTOR                                                   |//
	//| Runs at every new tick (begins with "start()" function)               |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int start()
	{
		start1(); start5(); // The first blocks in logic trees called one after another
		return(0);
	}

	//////////////////////////////////
	// Define block 1 (Empty block) //
	void start1()
	{
		start2(); start4();
	}

	//////////////////////////////////
	// Define block 2 (Empty block) //
	void start2()
	{
		start3();
	}

	//////////////////////////////////
	// Define block 3 (Empty block) //
	void start3()
	{
		/* Nothing here */
	}

	//////////////////////////////////
	// Define block 4 (Empty block) //
	void start4()
	{
		/* Nothing here */
	}

	//////////////////////////////////
	// Define block 5 (Empty block) //
	void start5()
	{
		start6(); start7();
	}

	//////////////////////////////////
	// Define block 6 (Empty block) //
	void start6()
	{
		/* Nothing here */
	}

	//////////////////////////////////
	// Define block 7 (Empty block) //
	void start7()
	{
		start8();
	}

	//////////////////////////////////
	// Define block 8 (Empty block) //
	void start8()
	{
		/* Nothing here */
	}

	/////////////////////////////////////////////////////////////////////////////
	//+-----------------------------------------------------------------------+//
	//| EXPERT DEINITIALIZATION SECTOR                                        |//
	//| Runs only once when expert unloads                                    |//
	//+-----------------------------------------------------------------------+//
	/////////////////////////////////////////////////////////////////////////////

	int deinit()
	{
		return(0);
	}

The logic is:
At each tick block 1 is runned
If block 1 passes -> Run block 2 and block 4
If block 2 passes -> Run block 3

At each tick block 5 is runned
If block 5 passes -> Run block 6 and block 7
If block 7 passes -> Run block 8

In Init() and DeInit() rules are the same. Only names for functions starts with "init" and deinit".

ID's of blocks are unique in global scope. So you can have only one block with ID #3 for example, no matter if it is in Init(), Start() or DeInit().