//define parameter
string filename;
filename = _Symbol + "-" + IntegerToString(dt.mon) + "-" + IntegerToString(dt.day) + ".txt";
void Write(string str)
{
int handle;
handle = FileOpen(filename, FILE_READ|FILE_WRITE|FILE_CSV, "/t");
FileSeek(handle, 0, SEEK_END);
FileWrite(handle, str + " Time " + TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS));
FileClose(handle);
}
bool CTrade::PositionOpen(const string symbol,ENUM_ORDER_TYPE order_type,double volume,
double price,double sl,double tp,const string comment)
{
string action,result;
//---
ClearStructures();
//--- checking
if(order_type!=ORDER_TYPE_BUY && order_type!=ORDER_TYPE_SELL)
{
m_result.retcode=TRADE_RETCODE_INVALID;
m_result.comment="Invalid order type";
return(false);
}
//--- setting request
m_request.action =TRADE_ACTION_DEAL;
m_request.symbol =symbol;
m_request.magic =m_magic;
m_request.volume =volume;
m_request.type =order_type;
m_request.price =price;
m_request.sl =sl;
m_request.tp =tp;
m_request.deviation =m_deviation;
m_request.type_filling=m_type_filling;
m_request.comment =comment;
//--- order check
if(!OrderCheck(m_request,m_check_result))
{
m_result.retcode=m_check_result.retcode;
printf(__FUNCTION__+": %s [%s]",FormatRequest(action,m_request),FormatRequestResult(result,m_request,m_result));
//--- copy return code
return(false);
}
//--- order send
if(!OrderSend(m_request,m_result))
{
printf(__FUNCTION__+": %s [%s]",FormatRequest(action,m_request),FormatRequestResult(result,m_request,m_result));
return(false);
}
printf(__FUNCTION__+": %s [%s]",FormatRequest(action,m_request),FormatRequestResult(result,m_request,m_result));
//--- ok
return(true);
}
struct string_double
{
string str_val;
double dbl_val;
}
string_double MyArray[SIZE];
//....
MyArray[0].str_val = "Hello, I'm string :)";
MyArray[0].dbl_val = 1;
for (i=0;i<OrdersTotal();i++){
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
if( OrderMagicNumber()==Magic){
if(OrderType()==OP_BUYSTOP || OrderType()==OP_BUY) Bought++;
if(OrderType()==OP_SELLSTOP || OrderType()==OP_SELL) Sold++;
}
}
if( Bought==0 ){ //no buy order
Ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots, Long ,3, SLLong, 0,Text,Magic,TimeCurrent() + 119*60*60,Blue);
}
void OnStart()
{
datetime from=0;
datetime to=TimeCurrent();
//--- request the entire history
HistorySelect(from,to);
//--- variables for returning values from order properties
ulong ticket;
double open_price;
double initial_volume;
datetime time_setup;
string symbol;
string type;
long order_magic;
long positionID;
//--- number of current pending orders
uint total=OrdersTotal();
//--- go through orders in a loop
for(uint i=0;i<total;i++)
{
//--- return order ticket by its position in the list
if((ticket=OrderGetTicket(i))>0)
{
//--- return order properties
open_price= OrderGetDouble(ORDER_PRICE_OPEN);
time_setup= OrderGetInteger(ORDER_TIME_SETUP);
symbol= OrderGetString(ORDER_SYMBOL);
order_magic= OrderGetInteger(ORDER_MAGIC);
positionID = OrderGetInteger(ORDER_POSITION_ID);
initial_volume= OrderGetDouble(ORDER_VOLUME_INITIAL);
type=GetOrderType(OrderGetInteger(ORDER_TYPE));
//--- prepare and show information about the order
printf("#ticket %d %s %G %s at %G was set up at %s",
ticket, // order ticket
type, // type
initial_volume, // placed volume
symbol, // symbol
open_price, // specified open price
TimeToString(time_setup)// time of order placing
);
}
}
//---
}
//+------------------------------------------------------------------+
//| returns the string name of the order type |
//+------------------------------------------------------------------+
string GetOrderType(long type)
{
string str_type="unknown operation";
switch(type)
{
case (ORDER_TYPE_BUY): return("buy");
case (ORDER_TYPE_SELL): return("sell");
case (ORDER_TYPE_BUY_LIMIT): return("buy limit");
case (ORDER_TYPE_SELL_LIMIT): return("sell limit");
case (ORDER_TYPE_BUY_STOP): return("buy stop");
case (ORDER_TYPE_SELL_STOP): return("sell stop");
case (ORDER_TYPE_BUY_STOP_LIMIT): return("buy stop limit");
case (ORDER_TYPE_SELL_STOP_LIMIT):return("sell stop limit");
}
return(str_type);
}
double High4=iHigh(Symbol(),PERIOD_H1,iHighest(Symbol(),PERIOD_H1,MODE_HIGH,4,1));
double Low4=iLow(Symbol(),PERIOD_H1,iLowest(Symbol(),PERIOD_H1,MODE_LOW,4,1));
double Med4=(High4+Low4)/2;
bool orderBuy=Ask>Med4;
bool orderSell=Bid<Med4;
etc…
double iHigh(string symbol,ENUM_TIMEFRAMES timeframe,int index)
{
double high=0;
ArraySetAsSeries(High,true);
int copied=CopyHigh(symbol,timeframe,0,TotalBars,High);
if(copied>0 && index<copied) high=High[index];
return(high);
}
int iHighest(string symbol,ENUM_TIMEFRAMES tf,int count=WHOLE_ARRAY,int start=0)
{
double High[];
ArraySetAsSeries(High,true);
CopyHigh(symbol,tf,start,count,High);
return(ArrayMaximum(High,0,count)+start);
return(0);
}
double iLow(string symbol,ENUM_TIMEFRAMES timeframe,int index)
{
double low=0;
ArraySetAsSeries(Low,true);
int copied=CopyLow(symbol,timeframe,0,TotalBars,Low);
if(copied>0 && index<copied) low=Low[index];
return(low);
}
int iLowest(string symbol,ENUM_TIMEFRAMES tf,int count=WHOLE_ARRAY,int start=0)
{
double Low[];
ArraySetAsSeries(Low,true);
CopyLow(symbol,tf,start,count,Low);
return(ArrayMinimum(Low,0,count)+start);
return(0);
}
CTrade trade;
MqlTick CurrentTick;
SymbolInfoTick(_Symbol,CurrentTick);
// open new position
double sl,tp; // set these to appropriate distance from CurrentTick.ask
if (!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,0.1,CurrentTick.ask,sl,tp,"comment"))
{
Print("Problem with CTrade::PositionOpen");
return;
}
// change sl and tp to new values
// sl=??????;
// tp=??????;
if (!trade.PositionModify(_Symbol,sl,tp))
{
Print("Problem with CTrade::PositionModify");
return;
}
int nBars=Bars(Symbol(),PERIOD_CURRENT);
if(m_nLastBars!=nBars){m_nLastBars=nBars;m_bNewBar=true;}
else
{m_bNewBar=false;}
double LastDealPrice() // Last Deal open price for chart symbol
{
uint total=0;
long ticket;
string symbol;
long magic;
HistorySelect(0,TimeCurrent());
total=HistoryDealsTotal();
for(uint i=0;i <total; i++)
{
ticket=HistoryDealGetTicket(i);
symbol=HistoryDealGetString(ticket,DEAL_SYMBOL);
magic=HistoryDealGetInteger(ticket,DEAL_MAGIC);
if( symbol==Symbol() && magic==MagicNumber)
{
Lprice=HistoryDealGetDouble(ticket,DEAL_PRICE);
}
}
return(Lprice);
}
int CurPosLots() // total lots in current symbol position
{
int total=PositionsTotal();
double lots=0;
for (int cnt=0; cnt<total; cnt++)
{
if(PositionSelect(Sysbol()) )
{
if(PositionGetInteger(POSITION_MAGIC)==MagicNumber)
{
lots=PositionGetDouble(POSITION_VOLUME);
}
}
}
return(lots);
}
SymbolInfoDouble(Symbol(),SYMBOL_BID);
MqlRates rates_arrayG[]; Int Bar=30; // read only 30 bars stating from the zero one iCopBar=CopyRates(Symbol(),PERIOD_M1,0,Bar,rates_arrayG);This feature saves both time and memory.
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int OnInit() { EventSetTimer(1); //each second we'll refer to OnTimer() } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnDeinit() { EventKillTimer(); // canceling of timer reference must be called at exit } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnTimer() { MqlDateTime str1; TimeGMT(str1); // new function to get GMT time Comment(str1.hour ,str1.min ,str1.sec ,str1.day ,str1.mon ,str1.year ,str1.day_of_year ,OrdersTotal() ,PositionsTotal() ); }So, control can be obtained not only at tick receipt as it was earlier, but also from the timer which allows writing real-time manageable programs. With this possibility more elaborate systems can be created.
MQL4 | MQL5 |
init | OnInit |
start | OnStart |
deinit | OnDeinit |
void OnInit() { //--- Functions is called to initialize init(); } void OnDeinit(const int reason) { //--- Call the function with deinitialization deinit(); //--- } |
mql5-program | main function |
OnStart | |
OnCalculate | |
OnTick |
MQL4 | MQL5 |
Digits | _Digits |
Point | _Point |
_LastError | |
_Period | |
_Symbol | |
_StopFlag | |
_UninitReason |
char , short , long , uchar , ushort , uint , ulongThis time the structures appear too:
struct, class
OBJ_ELLIOTWAVE5 , OBJ_ELLIOTWAVE3 , OBJ_ARROW_THUMB_UP , OBJ_ARROW_THUMB_DOWN, OBJ_ARROW_UP , OBJ_ARROW_DOWN , OBJ_ARROW_STOP , OBJ_ARROW_CHECK ,OBJ_ARROW_LEFT_PRICE, OBJ_ARROW_RIGHT_PRICE ,OBJ_BUTTON , OBJ_CHART , OBJ_BITMAP , OBJ_BITMAP_LABEL , OBJ_EDIT.Our opinion would be that OBJ_EDIT,OBJ_BUTTON si OBJ_CHART are the most important graphics objects. Once with OBJ_CHART comes the possibility to have chart in chart feature (to see inside a chart a different other charts). These objects are fully packed with properties, which leads to a better graphics object management.
// setting parameter
input double MaximumRisk = 0.02; // Maximum Risk in percentage
input double DecreaseFactor = 3; // Descrease factor
//+------------------------------------------------------------------+
//| Calculate optimal lot size |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
{
double price=1.0;
double margin=0.1;
//--- select lot size
if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price)) return(0.0);
if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin)) return(0.0);
if(margin<=0.0) return(0.0);
double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)*MaximumRisk/margin,2);
//--- calculate number of losses orders without a break
if(DecreaseFactor>0)
{
//--- select history for access
HistorySelect(0,TimeCurrent());
//---
int orders=HistoryDealsTotal(); // total history deals
int losses=0; // number of losses orders without a break
for(int i=orders-1;i>=0;i--)
{
ulong ticket=HistoryDealGetTicket(i);
if(ticket==0)
{
Print("HistoryDealGetTicket failed, no trade history");
break;
}
//--- check symbol
if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol) continue;
//--- check profit
double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
if(profit>0.0) break;
if(profit<0.0) losses++;
}
//---
if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
}
//--- normalize and check limits
double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
lot=stepvol*NormalizeDouble(lot/stepvol,0);
double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
if(lot<minvol) lot=minvol;
double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
if(lot>maxvol) lot=maxvol;
//--- return trading volume
return(lot);
}
//+------------------------------------------------------------------+
//| Calculation of the lot |
//+------------------------------------------------------------------+
double Calculate_Lot(double lot_value,int type,ENUM_ORDER_TYPE direction)
//+------------------------------------------------------------------+
{
double acc_free_margin=AccountInfoDouble(ACCOUNT_FREEMARGIN);
double calc_margin;
double price=0;
if(direction == ORDER_TYPE_BUY) price = tick.ask;
if(direction == ORDER_TYPE_SELL) price = tick.bid;
switch(type)
{
case fixed:
{
//--- Correction of lot size
if(LOT_CORRECTION)
{
OrderCalcMargin(direction,_Symbol,lot_value,price,calc_margin);
//--- Lot size correction of up to 90% of free margin
if(acc_free_margin<calc_margin)
{
lot_value=lot_value*acc_free_margin*0.9/calc_margin;
printf("Adjusted value of the lot: %f",lot);
}
}
break;
}
case percent:
{
//--- value of free margin for open position
OrderCalcMargin(direction,_Symbol,1,price,calc_margin);
lot_value=acc_free_margin*0.01*LOT/calc_margin;
break;
}
}// end switch
return(NormalizeLot(lot_value));
}
//+------------------------------------------------------------------+
//| Normalization of the lot size |
//+------------------------------------------------------------------+
double NormalizeLot(double lot_value)
//+------------------------------------------------------------------+
{
double lot_min = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
double lot_max = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
double lot_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
int norm;
if(lot_value <= lot_min ) lot_value = lot_min; // checking for minimum lot
else if(lot_value >= lot_max ) lot_value = lot_max; // checking the maximum lot
else(lot_value = MathFloor(lot_value/ lot_step) * lot_step); // rounding to the nearest
norm=(int)NormalizeDouble(MathCeil(MathLog10(1/lot_step)),0);// coefficient for NormalizeDouble
return(NormalizeDouble(lot_value,norm)); // normalization
}
//+------------------------------------------------------------------+
