Posts made by fxDreema

I am not good at creating experts. That's why maybe the best idea that I have is 2'nd example in Examples. This can be described as: buying only with huge limits - more than 300 pips, only when some big MA on big timeframe is rising.
Nothing with scalping, obviously. It's slow, it looks not attractive... but it shows some results over a big periods of time

Sometimes people ask me if there is a desktop version available. Currently, there is not. The main reason for this question is of course - sequrity of the projects and ideas.

Yes, all the projects are placed on the server. And yes, I have access to all of them. But I must ensure you that I have zero interest in any of the projects someone have. I have personally 5 or 6 margin calls (working manually) and honestly, I don't like trading Forex anymore. But I like the product I developed. I am the only one who is attached to FxDreema.

Why FxDreema is web-based? Well... because I started it like this. I have no experience programming PC applications, I am a web-applications developer and for me PHP is the easiest way to program something.

How many of you are worried about own projects and feel fear that they will be stolen?

Done. Without Custom blocks support for now.
Because this is new, some bugs may appear. Tell me if you find some.

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().