//+------------------------------------------------------------------+
//|                                                Multiplicator.mqh |
//|                             Copyright 2020, Thomas Schwabhaeuser |
//|                                               schwabts@gmail.com |
//+------------------------------------------------------------------+
#include <Controls\Dialog.mqh>
#include <Controls\RadioButton.mqh>
#include <Controls\Checkbox.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <Controls\SpinEdit.mqh>
#include <Controls\Edit.mqh>
#include <ChartObjects\ChartObjectsLines.mqh>
#include <Trade\SymbolInfo.mqh>
//---
#include "GridTk.mqh"                     // #include <Layouts\GridTk.mqh>
#include "DoubleSpinEdit.mqh"             // #include <Controls\DoubleSpinEdit.mqh>
//+------------------------------------------------------------------+
//| defines                                                          |
//+------------------------------------------------------------------+
#define LINES_TOTAL                          (3)
#define NUMBER_LINES                         (3)
//---
#define CONTROLS_WIDTH                      (80)
#define CONTROLS_HEIGHT                     (20)
#define EDIT_WIDTH                          (80)
//---
//---
#define GRID_ROWS                            (4)
#define GRID_COLS                            (4)
#define GRID_HGAP                            (5)
#define GRID_VGAP                            (5)
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum RADIO_ALIAS
  {
   RADIO_SELL=0,
   RADIO_BUY=1
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum LABEL_ALIAS
  {
   LABEL_RISK=0,
   LABEL_LOT=1,
   LABEL_LOSS_PIPS=2,
   LABEL_LOSS_MONEY =3,
   LABEL_TARGET_PIPS=4,
   LABEL_TARGET_GAIN=5
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum EDIT_ALIAS
  {
   EDIT_RISK=0,
   EDIT_ENTRY=1,
   EDIT_LOT=2,
   EDIT_LOSS_PIPS=3,
   EDIT_LOSS_MONEY = 4,
   EDIT_TARGET_PIPS= 5,
   EDIT_TARGET_GAIN=6
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum BUTTON_ALIAS
  {
   BUTTON_ENTRY=0
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum CHECKBOX_ALIAS
  {
//RESET_BUTTON=0,
   CHECKBOX_ENABLE_FIRST_TOP_UP=0,
   CHECKBOX_ENABLE_SECOND_TOP_UP=1,
   CHECKBOX_ENABLE_THIRD_TOP_UP=2
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum LINE_ALIAS
  {
   ENTRY_LINE= 0,
   LOSS_LINE = 1,
   PROFIT_LINE=2
  };
//---
string checkbox_name[]=
  {
   "Checkbox_Enable_TopUp1","Checkbox_Enable_TopUp2","Checkbox_Enable_TopUp3"
  };
string checkbox_text[]=
  {
   "Enable","Enable","Enable"
  };
string button_name[]= { "ButtonEnter" };
string button_text[]= { "Enter @" };
string label_name[]=
  {
   "RiskLabel",
   "LotLabel","LossPipsLabel","ProfitPipsLabel","LossMoneyLabel","ProfitMoneyLabel"
   "FirstTopUpLabel","SecondTopUpLabel","ThridTopUpLabel"
  };
string label_text[]=
  {
// first label with index 0 is hard coded to be hidden by CreateLabel()
//"INVISIBLE",
   "Risk (%):",
   "Lot:","Loss, pips:","Loss, ","Target, pips:","Target (%):",
   "TopUp1 (%):","TopUp2 (%):","TopUp3 (%):"
  };
string spinedit_name[]=
  {
   "RiskEdit",
   "EntryEdit","LotEdit","LossPipsEdit","ProfitPipsEdit","LossMoneyEdit","ProfitMoneyEdit"
  };
string radio_name[]= { "Sell","Buy" };
string line_name[LINES_TOTAL] = { "PLC_EntryLine", "PLC_LossLine", "PLC_ProfitLine" };
color line_color[LINES_TOTAL] = { clrOrange, clrRed, clrGreen };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CMultiplicator : public CAppDialog
  {
private:
   CSymbolInfo       SymbolInfo;
   long              OrderType;
   double            EntryPrice;
   double            StopPrice;
   double            TargetPrice;
   double            LotValue;
   int               TopUpLevelNumber;

   //--- UI Controls
   CSize             CellSize;
   CGridTk           Layout;

   // TODO:    define arrays storing control objects as Dynamic Arrays
   // TODO:    define new controls grouping edit fields with labels, checkboxes, and/or lines
   CRadioButton      RadioButton[];
   CCheckBox         CheckBox[];
   CButton           Button[];
   CLabel            Label[];
   CDoubleSpinEdit   SpinEdit[];
   CChartObjectHLine Line[LINES_TOTAL];

public:
                     CMultiplicator();
                    ~CMultiplicator();
   virtual bool      Create(const long chart,const string name,const int subwin,
                            const int x1,const int y1,const int x2,const int y2);
   virtual void      Destroy(const int reason=REASON_PROGRAM);
   virtual bool      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
   virtual bool      OnEventLine(const int id,const long &lparam,const double &dparam,const string &sparam);
   //--- parameters
   void              TopUpLevels(int value)  { this.TopUpLevelNumber = value; }
   int               TopUpLevels()           { return(this.TopUpLevelNumber); }

protected:
   //--- create lines and controls
   bool              CreateLayout();
   bool              CreateLines(int index);
   bool              CreateTopUpLevel(int index);
   bool              CreateTopUpLabel(int index);
   bool              CreateTopUpEdit(int index);
   bool              CreateTopUpStopLabel(int index);
   bool              CreateRadioButton(int index);
   bool              CreateCheckBox(int index);
   bool              CreateButton(int index);
   bool              CreateLabel(int index);
   bool              CreateDoubleSpinEdit(int index);
   //--- handlers of the dependent controls events
   bool              OnChangeType(int index);
   bool              OnChangeCheckBox(int index);
   virtual bool              OnChangeEnableFirstTopUp() { return(true); }
   virtual bool              OnChangeEnableSecondTopUp() { return(true); }
   virtual bool              OnChangeEnableThirdTopUp() { return(true); }
   bool              OnClickButton(int index);
   bool              OnChangeDoubleSpinEdit(int index);

   void              OnChangeEntry();
   void              OnChangeLot();
   void              OnChangeLossPips();
   void              OnChangeProfitPips();
   void              OnChangeLossMoney();
   void              OnChangeProfitMoney();

   void              OnChangeEntryLine();
   void              OnChangeLossLine();
   void              OnChangeProfitLine();

   //---
   void              ResetData();
   void              UpdateProfitLoss();
   int               LossPips();
   int               MaxLossPips();
   int               ProfitPips();
   int               MaxProfitPips();
   double            CalculateMoney(double exit_price);
   double            LossMoney();
   double            MinLossMoney();
   double            MaxLossMoney();
   double            ProfitMoney();
   double            MinProfitMoney();
   double            MaxProfitMoney();
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CMultiplicator::CMultiplicator()
  {
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CMultiplicator::~CMultiplicator()
  {
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
EVENT_MAP_BEGIN(CMultiplicator)
ON_INDEXED_EVENT(ON_CHANGE,RadioButton,OnChangeType)
//ON_INDEXED_EVENT(ON_CHANGE,CheckBox,OnChangeCheckBox)
ON_INDEXED_EVENT(ON_CLICK,Button,OnClickButton)
ON_INDEXED_EVENT(ON_CHANGE,SpinEdit,OnChangeDoubleSpinEdit)
EVENT_MAP_END(CAppDialog)
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::Create(const long chart,const string name,const int subwin,
                            const int x1,const int y1,const int x2,const int y2)
  {
//---
   bool ok=true;

   for(int i=0; i<ArraySize(line_name); i++)
     {
      if(!CreateLines(i))
         return(false);
     }
   if(!CAppDialog::Create(chart,name,subwin,x1,y1,x2,y2))
      return(false);
   if(!CreateLayout())
      return(false);
   this.Layout.VerticalAlign(VERTICAL_ALIGN_TOP);

//---
   for(int i=0; i<2; i++)
     {
      if(!CreateRadioButton(i))
         return(false);
     }
   if(!CreateLabel(0))
      return(false);
   if(!CreateDoubleSpinEdit(EDIT_RISK))
      return(false);
//---
   if(!CreateButton(0))
      return(false);
   for(int i=0; i<5; i++)
     {
      if(!CreateDoubleSpinEdit(ArraySize(this.SpinEdit)))
         return(false);
      if(!CreateLabel(ArraySize(this.Label)))
         return(false);
     }
   if(!CreateDoubleSpinEdit(ArraySize(this.SpinEdit)))
      return(false);
//--- TODO: add top up level configuration
//if(this.TopUpLevelNumber>0)
   PrintFormat(__FUNCTION__+": adding %d top up level configurators",this.TopUpLevelNumber);

   for(int i=0; i<this.TopUpLevelNumber; i++)
      if(!CreateTopUpLevel(i))
         return(false);

//for(int i=0; i<3; i++)
//  {
//   if(!CreateLabel(ArraySize(this.Label)))
//      return(false);
//   if(!CreateDoubleSpinEdit(ArraySize(this.SpinEdit)))
//      return(false);
//  }

   ResetData();

   if(!this.Layout.Pack())
      return(false);
   if(!Add(this.Layout))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::Destroy(const int reason=REASON_PROGRAM)
  {
   for(int i=0; i<ArraySize(this.CheckBox); i++)
     {
      this.CheckBox[i].Destroy();
     }
   for(int i=0; i<ArraySize(this.RadioButton); i++)
     {
      this.RadioButton[i].Destroy();
     }
   for(int i=0; i<ArraySize(this.Button); i++)
     {
      this.Button[i].Destroy();
     }
   for(int i=0; i<ArraySize(this.Label); i++)
     {
      this.Label[i].Destroy();
     }
   for(int i=0; i<ArraySize(this.SpinEdit); i++)
     {
      this.SpinEdit[i].Destroy();
     }
   for(int i=0; i<NUMBER_LINES; i++)
     {
      this.Line[i].Delete();
     }
   this.Layout.Destroy(reason);
   CAppDialog::Destroy(reason);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateLayout()
  {
   CSize size=Size();
   if(!this.Layout.Create(m_chart_id,m_name+"main",m_subwin,0,0,CDialog::ClientAreaWidth(),CDialog::ClientAreaHeight()))
      return(false);
   this.Layout.LayoutStyle(LAYOUT_STYLE_VERTICAL);
   int rows=GRID_ROWS+this.TopUpLevelNumber;
   int cols=GRID_COLS;
   int hgap=GRID_HGAP;
   int vgap=GRID_VGAP;
   this.Layout.Init(rows,cols,hgap,vgap);
   this.CellSize.cx = CONTROLS_WIDTH;
   this.CellSize.cy = CONTROLS_HEIGHT;
   PrintFormat("ok: Layout.Create(%d,%s,%d,0,0,%d,%d) ... rows=%d,cols=%d,hgap=%d,vgap=%d",
               m_chart_id,m_name+"main",m_subwin,
               CDialog::ClientAreaWidth(),CDialog::ClientAreaHeight(),
               rows,cols,hgap,vgap);
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateLines(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.Line))
     {
      ArrayResize(this.Line,index+1);
     }
//---
   bool ok=true;

   if(ObjectFind(0,line_name[index])<0)
     {
      ok=this.Line[index].Create(0,line_name[index],0,0.0);
      ok &= this.Line[index].Color(line_color[index]);
      ok &= this.Line[index].Selectable(true);
      if(!ok)
        {
         return(false);
        }
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateTopUpLevel(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.Label))
     {
      ArrayResize(this.Label,index+1);
     }
//+------------------------------------------------------------------+
//| Redesign the row to look like                                    |
//| [ ] Enb ith TopUp | <lot> | {price} | <P/L>                      |
//+------------------------------------------------------------------+
   if(!CreateCheckBox(index))
      return(false);
   if(!CreateTopUpLabel(index))
      return(false);
   if(!CreateTopUpEdit(index))
      return(false);
   if(!CreateTopUpStopLabel(index))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateTopUpLabel(int index)
  {
   int top_up_number=index+1;
   index=ArraySize(this.Label);
   ArrayResize(this.Label,index+1);
//---
   CLabel *label=GetPointer(this.Label[index]);

   string fullname=m_name+StringFormat("TopUp%dLabel",top_up_number);
   if(!label.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);

   string text=StringFormat("%d. TopUp @",top_up_number);
   if(!label.Text(text))
      return(false);

   if(!this.Layout.Add(label))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateTopUpEdit(int index)
  {
   PrintFormat(__FUNCTION__+"(%d): implement me for creating the edit field to set a price for adding",index);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateTopUpStopLabel(int index)
  {
   int top_up_number=index+1;
   index=ArraySize(this.Label);
   ArrayResize(this.Label,index+1);
//---
   CLabel *label=GetPointer(this.Label[index]);

   string fullname=m_name+StringFormat("TopUp%dStopLabel",top_up_number);
   if(!label.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);

   string text=StringFormat("P/L:",top_up_number);
   if(!label.Text(text))
      return(false);

   if(!this.Layout.Add(label))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateButton(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.Button))
     {
      ArrayResize(this.Button,index+1);
     }
//---
   CButton *button;
   button=GetPointer(this.Button[index]);

   string fullname=m_name+button_name[index];
   if(!button.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);
//   PrintFormat("ok: Button[%d,%s].Create(%d,%s,%d,0,0,%d,%d)",index,EnumToString((BUTTON_ALIAS)index),
//               m_chart_id,fullname,m_subwin,this.CellSize.cx,this.CellSize.cy);

   if(!button.Text(button_text[index]))
      return(false);
   if(!this.Layout.Add(button))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateRadioButton(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.RadioButton))
     {
      ArrayResize(this.RadioButton,index+1);
     }
//---
   bool ok=true;

   CRadioButton *radiobutton=GetPointer(this.RadioButton[index]);
   string fullname=m_name+"_Radio_"+radio_name[index];
   ok=radiobutton.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy);
//   PrintFormat("ok: RadioButton[%d,%s].Create(%d,%s,%d,0,0,%d,%d)",index,EnumToString((RADIO_ALIAS)index),
//               m_chart_id,fullname,m_subwin,this.CellSize.cx,this.CellSize.cy);
   ok&=radiobutton.Text(radio_name[index]);
   ok&=radiobutton.State(index==0);
   if(!ok)
      return(false);
   if(!this.Layout.Add(radiobutton))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateCheckBox(int index)
  {
   PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.CheckBox))
     {
      ArrayResize(this.CheckBox,index+1);
     }
//---
   CCheckBox *checkbox=GetPointer(this.CheckBox[index]);
   string fullname=m_name+checkbox_name[index];
   if(!checkbox.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);
//   PrintFormat("ok: CheckBox[%d,%s].Create(%d,%s,%d,0,0,%d,%d)",index,EnumToString((CHECKBOX_ALIAS)index),
//               m_chart_id,fullname,m_subwin,this.CellSize.cx,this.CellSize.cy);

   if(!checkbox.Text(checkbox_text[index]))
      return(false);
   if(!this.Layout.Add(checkbox))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateLabel(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.Label))
     {
      ArrayResize(this.Label,index+1);
     }
//---
   string currency=AccountInfoString(ACCOUNT_CURRENCY);
   CLabel *label=GetPointer(this.Label[index]);

   string fullname=m_name+label_name[index];
   if(!label.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);

   string text=label_text[index];
   if(index==LABEL_LOSS_MONEY)
      text+=currency+":";
   if(!label.Text(text))
      return(false);

   if(!this.Layout.Add(label))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::CreateDoubleSpinEdit(int index)
  {
//PrintFormat(__FUNCTION__+"(%d) ...",index);
   if(index>=ArraySize(this.SpinEdit))
     {
      ArrayResize(this.SpinEdit,index+1);
     }
//---
   string currency=AccountInfoString(ACCOUNT_CURRENCY);

   CDoubleSpinEdit *spinedit=GetPointer(this.SpinEdit[index]);
   if(spinedit==NULL)
     {
      PrintFormat("failed: (pointer->SpinEdit[%d])!=NULL",index);
      return(false);
     }
//PrintFormat("ok: (pointer->SpinEdit[%d,%s])!=NULL",index,EnumToString((EDIT_ALIAS)index));

   string fullname=m_name+spinedit_name[index];
   if(!spinedit.Create(m_chart_id,fullname,m_subwin,0,0,this.CellSize.cx,this.CellSize.cy))
      return(false);
//   PrintFormat("ok: SpinEdit[%d,%s].Create(%d,%s,%d,0,0,%d,%d)",index,EnumToString((EDIT_ALIAS)index),
//               m_chart_id,fullname,m_subwin,this.CellSize.cx,this.CellSize.cy);

   spinedit.ReadOnly(false);
   if(!this.Layout.Add(spinedit))
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::OnChangeCheckBox(int index)
  {
// PrintFormat(__FUNCTION__+"(%s)",EnumToString((BUTTON_ALIAS)index));
//---
   switch(index)
     {
      case CHECKBOX_ENABLE_FIRST_TOP_UP:
         OnChangeEnableFirstTopUp();
         break;
      case CHECKBOX_ENABLE_SECOND_TOP_UP:
         OnChangeEnableSecondTopUp();
         break;
      case CHECKBOX_ENABLE_THIRD_TOP_UP:
         OnChangeEnableThirdTopUp();
         break;
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::OnClickButton(int index)
  {
   switch(index)
     {
      case BUTTON_ENTRY:
         if(this.OrderType==(long)ORDER_TYPE_BUY)
            //PlaceBuyOrder();
            Print(__FUNCTION__+": buy "+this.LotValue+" "+this.SymbolInfo.Name()+" "+
                  "@"+DoubleToString(this.EntryPrice,this.SymbolInfo.Digits())+
                  ", sl="+DoubleToString(this.StopPrice,this.SymbolInfo.Digits())+
                  ", tp="+DoubleToString(this.TargetPrice,this.SymbolInfo.Digits())
                 );
         if(this.OrderType==(long)ORDER_TYPE_SELL)
            //PlaceSellOrder();
            Print(__FUNCTION__+": sell "+this.LotValue+" "+this.SymbolInfo.Name()+" "+
                  "@"+DoubleToString(this.EntryPrice,this.SymbolInfo.Digits())+
                  ", sl="+DoubleToString(this.StopPrice,this.SymbolInfo.Digits())+
                  ", tp="+DoubleToString(this.TargetPrice,this.SymbolInfo.Digits())
                 );
         break;
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::ResetData()
  {
//---
   bool ok=false;
   double min_price=0.0,max_price=0.0;

   this.SymbolInfo.Name(_Symbol);

   for(int tries=1; tries<5; tries++)
     {
      if(this.SymbolInfo.IsSynchronized() && this.SymbolInfo.Refresh()
         && ChartGetDouble(m_chart_id,CHART_PRICE_MIN,m_subwin,min_price)
         && ChartGetDouble(m_chart_id,CHART_PRICE_MAX,m_subwin,max_price))
        {
         ok=true;
         break;
        }
      Sleep(1000);
     }

   if(ok)
     {
      //--- members
      this.OrderType=(long)ORDER_TYPE_BUY;
      this.EntryPrice= NormalizeDouble((max_price+min_price)/2,this.SymbolInfo.Digits());
      this.StopPrice = NormalizeDouble(this.EntryPrice-(this.EntryPrice-min_price)/2,this.SymbolInfo.Digits());
      this.TargetPrice=NormalizeDouble(max_price-(max_price-this.EntryPrice)/2,this.SymbolInfo.Digits());
      this.LotValue=NormalizeDouble(10*this.SymbolInfo.LotsMin(),2);

      //--- lines
      this.Line[ENTRY_LINE].Price(0,this.EntryPrice);
      this.Line[LOSS_LINE].Price(0,this.StopPrice);
      this.Line[PROFIT_LINE].Price(0,this.TargetPrice);
      for(int i=0; i<ArraySize(line_name); i++)
        {
         this.Line[i].Selected(false);
        }
      //--- controls
      this.RadioButton[RADIO_BUY].State(true);
      this.RadioButton[RADIO_SELL].State(false);
      this.SpinEdit[EDIT_ENTRY].SetParameters(this.EntryPrice,min_price,max_price,100*this.SymbolInfo.TickSize(),this.SymbolInfo.Digits());
      this.SpinEdit[EDIT_LOT].SetParameters(this.LotValue,this.SymbolInfo.LotsMin(),this.SymbolInfo.LotsMax(),10*this.SymbolInfo.LotsStep(),
                                            (int)NormalizeDouble(MathCeil(MathLog10(1/this.SymbolInfo.LotsStep())),0));
      UpdateProfitLoss();
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::UpdateProfitLoss(void)
  {
//---
   this.SpinEdit[EDIT_LOSS_PIPS].SetParameters(LossPips(),this.SymbolInfo.StopsLevel(),MaxLossPips(),
         100*this.SymbolInfo.TickSize()/this.SymbolInfo.Point(),0);
   this.SpinEdit[EDIT_TARGET_PIPS].SetParameters(ProfitPips(),this.SymbolInfo.StopsLevel(),MaxProfitPips(),
         100*this.SymbolInfo.TickSize()/this.SymbolInfo.Point(),0);
   this.SpinEdit[EDIT_LOSS_MONEY].SetParameters(LossMoney(),MinLossMoney(),
         MaxLossMoney(),10,2);
//PrintFormat("%s: ArraySize(this.SpinEdit)==%d, EDIT_TARGET_GAIN=%d",
//            __FUNCTION__,ArraySize(this.SpinEdit),EDIT_TARGET_GAIN);
   this.SpinEdit[EDIT_TARGET_GAIN].SetParameters(ProfitMoney(),MinProfitMoney(),
         MaxProfitMoney(),10,2);
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CMultiplicator::LossPips(void)
  {
   return(int(MathAbs(MathRound((this.EntryPrice - this.StopPrice)/this.SymbolInfo.Point()))));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CMultiplicator::MaxLossPips(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.SpinEdit[EDIT_ENTRY].MinValue() : this.SpinEdit[EDIT_ENTRY].MaxValue());
   return(int(MathAbs(MathRound((this.EntryPrice - price)/this.SymbolInfo.Point()))) + this.SymbolInfo.StopsLevel());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CMultiplicator::ProfitPips(void)
  {
   return(int(MathAbs(MathRound((this.EntryPrice - this.TargetPrice)/this.SymbolInfo.Point()))));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CMultiplicator::MaxProfitPips(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.SpinEdit[EDIT_ENTRY].MaxValue() : this.SpinEdit[EDIT_ENTRY].MinValue());
   return(int(MathAbs(MathRound((this.EntryPrice - price)/this.SymbolInfo.Point()))) + this.SymbolInfo.StopsLevel());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::CalculateMoney(double exit_price)
  {
   double result=0.0;

   ResetLastError();
   if(!OrderCalcProfit((ENUM_ORDER_TYPE)this.OrderType,this.SymbolInfo.Name(),this.LotValue,
                       this.EntryPrice,exit_price,result))
     {
      Print(__FUNCTION__,": calculating money failed. Error #",GetLastError());
     }
//---
   return(NormalizeDouble(MathAbs(result), 2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::LossMoney(void)
  {
   return(CalculateMoney(this.StopPrice));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::MinLossMoney(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.EntryPrice-this.SymbolInfo.StopsLevel() * this.SymbolInfo.Point()
                 : this.EntryPrice+this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point());

   return(CalculateMoney(price));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::MaxLossMoney(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.SpinEdit[EDIT_ENTRY].MinValue() - this.SymbolInfo.StopsLevel() * this.SymbolInfo.Point()
                 : this.SpinEdit[EDIT_ENTRY].MaxValue()+this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point());

   return(CalculateMoney(price));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::ProfitMoney(void)
  {
   return(CalculateMoney(this.TargetPrice));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::MinProfitMoney(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.EntryPrice+this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point()
                 : this.EntryPrice-this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point());

   return(CalculateMoney(price));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CMultiplicator::MaxProfitMoney(void)
  {
   double price=((this.OrderType==(long)ORDER_TYPE_BUY)
                 ? this.SpinEdit[EDIT_ENTRY].MaxValue() + this.SymbolInfo.StopsLevel() * this.SymbolInfo.Point()
                 : this.SpinEdit[EDIT_ENTRY].MinValue()-this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point());

   return(CalculateMoney(price));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::OnChangeType(int index)
  {
//---
   if(this.RadioButton[index].State())
     {
      int other_index=1-index;
      bool other_prev_state=this.RadioButton[other_index].State();

      this.RadioButton[other_index].State(false);
      switch(index)
        {
         case RADIO_SELL:
            this.OrderType=(long)ORDER_TYPE_SELL;
            break;
         case RADIO_BUY:
            this.OrderType=(long)ORDER_TYPE_BUY;
            break;
        };

      if(other_prev_state!=this.RadioButton[other_index].State())
        {
         double tmp=this.StopPrice;

         this.StopPrice=this.TargetPrice;
         this.TargetPrice=tmp;
         this.Line[LOSS_LINE].Price(0,this.StopPrice);
         this.Line[PROFIT_LINE].Price(0,this.TargetPrice);
         UpdateProfitLoss();
        }
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::OnChangeDoubleSpinEdit(int index)
  {
//---
   switch(index)
     {
      case EDIT_ENTRY:
         OnChangeEntry();
         break;
      case EDIT_LOT:
         OnChangeLot();
         break;
      case EDIT_LOSS_PIPS:
         OnChangeLossPips();
         break;
      case EDIT_TARGET_PIPS:
         OnChangeProfitPips();
         break;
      case EDIT_LOSS_MONEY:
         OnChangeLossMoney();
         break;
      case EDIT_TARGET_GAIN:
         OnChangeProfitMoney();
         break;
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeEntry(void)
  {
//---
   double new_entry = this.SpinEdit[EDIT_ENTRY].Value();
   double valid_max = MathMax(this.StopPrice, this.TargetPrice) - this.SymbolInfo.StopsLevel() * this.SymbolInfo.Point();
   double valid_min = MathMin(this.StopPrice, this.TargetPrice) + this.SymbolInfo.StopsLevel() * this.SymbolInfo.Point();

   if(new_entry>valid_max || new_entry<valid_min)
     {
      this.SpinEdit[EDIT_ENTRY].Value(this.EntryPrice);
      return;
     }

   if(new_entry!=this.EntryPrice)
     {
      this.EntryPrice=new_entry;
      this.Line[ENTRY_LINE].Price(0,this.EntryPrice);
      this.SpinEdit[EDIT_LOSS_PIPS].Value(LossPips());
      this.SpinEdit[EDIT_TARGET_PIPS].Value(ProfitPips());
      this.SpinEdit[EDIT_LOSS_MONEY].Value(LossMoney());
      this.SpinEdit[EDIT_TARGET_GAIN].Value(ProfitMoney());
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeLot(void)
  {
//---
   double new_lot=this.SpinEdit[1].Value();

   if(new_lot!=this.LotValue)
     {
      this.LotValue=new_lot;
      UpdateProfitLoss();
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeLossPips(void)
  {
//---
   int old_value = LossPips();
   int new_value = (int)this.SpinEdit[EDIT_LOSS_PIPS].Value();

   if(new_value!=old_value)
     {
      if(this.OrderType==(long)ORDER_TYPE_BUY)
        {
         this.StopPrice=NormalizeDouble(this.EntryPrice-new_value*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      else
        {
         this.StopPrice=NormalizeDouble(this.EntryPrice+new_value*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      this.Line[LOSS_LINE].Price(0,this.StopPrice);
      this.SpinEdit[EDIT_LOSS_MONEY].Value(LossMoney());
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeProfitPips(void)
  {
//---
   int old_value = ProfitPips();
   int new_value = (int)this.SpinEdit[EDIT_TARGET_PIPS].Value();

   if(new_value!=old_value)
     {
      if(this.OrderType==(long)ORDER_TYPE_BUY)
        {
         this.TargetPrice=NormalizeDouble(this.EntryPrice+new_value*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      else
        {
         this.TargetPrice=NormalizeDouble(this.EntryPrice-new_value*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      this.Line[PROFIT_LINE].Price(0,this.TargetPrice);
      this.SpinEdit[EDIT_TARGET_GAIN].Value(ProfitMoney());
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeLossMoney(void)
  {
//---
   double old_value = LossMoney();
   double new_value = this.SpinEdit[EDIT_LOSS_MONEY].Value();

   if(new_value!=old_value)
     {
      int loss_pips=int(new_value/(this.LotValue*this.SymbolInfo.TickValueLoss()));

      this.SpinEdit[EDIT_LOSS_PIPS].Value(loss_pips);
      if(this.OrderType==(long)ORDER_TYPE_BUY)
        {
         this.StopPrice=NormalizeDouble(this.EntryPrice-loss_pips*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      else
        {
         this.StopPrice=NormalizeDouble(this.EntryPrice+loss_pips*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      this.Line[LOSS_LINE].Price(0,this.StopPrice);
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeProfitMoney(void)
  {
//---
   double old_value = ProfitMoney();
   double new_value = this.SpinEdit[EDIT_TARGET_GAIN].Value();

   if(new_value!=old_value)
     {
      int profit_pips=int(new_value/(this.LotValue*this.SymbolInfo.TickValueProfit()));

      this.SpinEdit[EDIT_TARGET_PIPS].Value(profit_pips);
      if(this.OrderType==(long)ORDER_TYPE_BUY)
        {
         this.TargetPrice=NormalizeDouble(this.EntryPrice+profit_pips*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      else
        {
         this.TargetPrice=NormalizeDouble(this.EntryPrice-profit_pips*this.SymbolInfo.Point(),this.SymbolInfo.Digits());
        }
      this.Line[PROFIT_LINE].Price(0,this.TargetPrice);
     }
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CMultiplicator::OnEventLine(const int id,const long &lparam,
                                 const double &dparam,const string &sparam)
  {
//---
   if(id==CHARTEVENT_OBJECT_CHANGE || id==CHARTEVENT_OBJECT_DRAG)
     {
      if(sparam==line_name[ENTRY_LINE])
        {
         OnChangeEntryLine();
        }
      else
         if(sparam==line_name[LOSS_LINE])
           {
            OnChangeLossLine();
           }
         else
            if(sparam==line_name[PROFIT_LINE])
              {
               OnChangeProfitLine();
              }
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeEntryLine(void)
  {
//---
   double new_price=NormalizeDouble(ObjectGetDouble(0,line_name[ENTRY_LINE],OBJPROP_PRICE),_Digits);
   double stops_level=this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point();
   bool valid_buy_entry=(this.OrderType==(long)ORDER_TYPE_SELL
                         && new_price<this.StopPrice-stops_level
                         && new_price>this.TargetPrice+stops_level);
   bool valid_sell_entry=(this.OrderType==(long)ORDER_TYPE_BUY
                          && new_price<this.TargetPrice-stops_level
                          && new_price>this.StopPrice+stops_level);

   if(!valid_buy_entry && !valid_sell_entry)
     {
      this.Line[ENTRY_LINE].Price(0,this.EntryPrice);
      ChartRedraw();
      return;
     }

   this.EntryPrice=new_price;
   this.SpinEdit[EDIT_ENTRY].Value(new_price);
   this.SpinEdit[EDIT_LOSS_PIPS].Value(LossPips());
   this.SpinEdit[EDIT_TARGET_PIPS].Value(ProfitPips());
   this.SpinEdit[EDIT_LOSS_MONEY].Value(LossMoney());
   this.SpinEdit[EDIT_TARGET_GAIN].Value(ProfitMoney());
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeLossLine(void)
  {
//---
   double new_price=NormalizeDouble(ObjectGetDouble(0,line_name[LOSS_LINE],OBJPROP_PRICE),_Digits);
   double stops_level=this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point();
   bool valid_buy_loss=(this.OrderType==(long)ORDER_TYPE_BUY
                        && new_price >= this.SpinEdit[EDIT_ENTRY].MinValue() - stops_level
                        && new_price <= this.EntryPrice - stops_level);
   bool valis_sell_loss=(this.OrderType==(long)ORDER_TYPE_SELL
                         && new_price <= this.SpinEdit[EDIT_ENTRY].MaxValue() + stops_level
                         && new_price >= this.EntryPrice + stops_level);

   if(!valid_buy_loss && !valis_sell_loss)
     {
      this.Line[LOSS_LINE].Price(0,this.StopPrice);
      ChartRedraw();
      return;
     }

   this.StopPrice=new_price;
   this.SpinEdit[EDIT_LOSS_PIPS].Value(LossPips());
   this.SpinEdit[EDIT_LOSS_MONEY].Value(LossMoney());
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMultiplicator::OnChangeProfitLine(void)
  {
//---
   double new_price=NormalizeDouble(ObjectGetDouble(0,line_name[PROFIT_LINE],OBJPROP_PRICE),_Digits);
   double stops_level=this.SymbolInfo.StopsLevel()*this.SymbolInfo.Point();
   bool valid_buy_profit=(this.OrderType==(long)ORDER_TYPE_BUY
                          && new_price <= this.SpinEdit[EDIT_ENTRY].MaxValue() + stops_level
                          && new_price >= this.EntryPrice + stops_level);
   bool valid_sell_profit=(this.OrderType==(long)ORDER_TYPE_SELL
                           && new_price >= this.SpinEdit[EDIT_ENTRY].MinValue() - stops_level
                           && new_price <= this.EntryPrice - stops_level);

   if(!valid_buy_profit && !valid_sell_profit)
     {
      this.Line[PROFIT_LINE].Price(0,this.TargetPrice);
      ChartRedraw();
      return;
     }

   this.TargetPrice=new_price;
   this.SpinEdit[EDIT_TARGET_PIPS].Value(ProfitPips());
   this.SpinEdit[EDIT_TARGET_GAIN].Value(ProfitMoney());
//---
  }
//+------------------------------------------------------------------+