交易控制面板EA

#property copyright "XAUOF Indicator Studio"
#property version   "1.30"

#include <Trade\Trade.mqh>

//--- 输入参数
input group "=== 开仓设置 ==="
input double InpLotSize = 0.01;       // 默认开仓手数
input double InpLotStep = 0.01;       // 手数调节步长
input double InpMinLot = 0.01;        // 最小手数
input double InpMaxLot = 10.0;        // 最大手数

input group "=== 加仓设置 ==="
input bool InpEnableAddPosition = true;   // 启用加仓功能
input double InpAddLotMultiplier = 1.5;   // 加仓手数倍数（相对上一单）
input int InpTrendAddDistance = 200;      // 顺势加仓间距（点数，盈利后）
input int InpCounterAddDistance = 300;    // 逆势加仓间距（点数，浮亏后）
input int InpMaxAddTimes = 3;             // 最大加仓次数

input group "=== 止盈止损设置 ==="
input int InpTakeProfit = 500;        // 固定止盈点数（0=不设置）
input int InpStopLoss = 300;          // 固定止损点数（0=不设置）
input bool InpAutoSetTPSL = true;     // 开仓时自动设置止盈止损

input group "=== 移动止盈 ==="
input bool InpEnableTrailing = true;  // 启用移动止盈
input int InpTrailStart = 300;        // 移动止盈触发点数
input int InpTrailDistance = 150;     // 移动止盈距离点数

input group "=== 保本设置 ==="
input int InpBreakEvenPoints = 50;    // 保本后加点数（开仓价之上/下）

input group "=== 面板设置 ==="
input int InpPanelX = 20;             // 面板初始X坐标
input int InpPanelY = 30;             // 面板初始Y坐标
input color InpCloseColor = clrCrimson;   // 平仓按钮颜色
input color InpOpenColor = clrForestGreen; // 开仓按钮颜色
input color InpAddColor = clrOrange;      // 加仓按钮颜色
input color InpSetColor = clrDodgerBlue;  // 设置按钮颜色

//--- 全局变量
CTrade trade;
int timerCounter = 0;
double currentLotSize = 0.01;

//--- 面板拖动相关
bool isDragging = false;
int dragStartX = 0;
int dragStartY = 0;
int panelX = 0;
int panelY = 0;

//--- 面板尺寸
int panelWidth = 140;
int panelHeight = 450;

//--- 对象名称常量
#define PANEL_BG         "panelBG"
#define PANEL_TITLE      "panelTitle"
#define BTN_OPEN_BUY     "btnOpenBuy"
#define BTN_OPEN_SELL    "btnOpenSell"
#define BTN_LOT_UP       "btnLotUp"
#define BTN_LOT_DOWN     "btnLotDown"
#define LABEL_LOT        "lblLot"
#define BTN_ADD_TREND    "btnAddTrend"
#define BTN_ADD_COUNTER  "btnAddCounter"
#define BTN_CLOSE_ALL    "btnCloseAll"
#define BTN_CLOSE_BUY    "btnCloseBuy"
#define BTN_CLOSE_SELL   "btnCloseSell"
#define BTN_SET_TP       "btnSetTP"
#define BTN_SET_SL       "btnSetSL"
#define BTN_BREAKEVEN    "btnBreakEven"
#define LABEL_INFO       "lblInfo"

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(0);
   trade.SetDeviationInPoints(10);
   
   if(!trade.SetTypeFillingBySymbol(_Symbol))
      trade.SetTypeFilling(ORDER_FILLING_FOK);
   
   currentLotSize = InpLotSize;
   currentLotSize = NormalizeDouble(MathMax(InpMinLot, MathMin(InpMaxLot, currentLotSize)), 2);
   
   panelX = InpPanelX;
   panelY = InpPanelY;
   
   CreatePanel();
   EventSetTimer(1);
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   DeletePanel();
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   UpdateInfoLabel();
   
   // 自动加仓检查
   if(InpEnableAddPosition)
   {
      CheckAutoAddPosition();
   }
}

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   timerCounter++;
   if(timerCounter >= 1)
   {
      timerCounter = 0;
      if(InpEnableTrailing)
         TrailingStop();
   }
   UpdateInfoLabel();
}

//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
   // 处理鼠标拖动
   if(id == CHARTEVENT_MOUSE_MOVE)
   {
      int x = (int)lparam;
      int y = (int)dparam;
      int flags = (int)sparam;
      
      if((flags & 1) == 1)
      {
         if(!isDragging)
         {
            if(x >= panelX && x <= panelX + panelWidth && 
               y >= panelY && y <= panelY + 25)
            {
               isDragging = true;
               dragStartX = x - panelX;
               dragStartY = y - panelY;
            }
         }
         else
         {
            panelX = x - dragStartX;
            panelY = y - dragStartY;
            
            if(panelX < 0) panelX = 0;
            if(panelY < 0) panelY = 0;
            
            int chartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
            int chartHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
            
            if(panelX + panelWidth > chartWidth) 
               panelX = chartWidth - panelWidth;
            if(panelY + panelHeight > chartHeight) 
               panelY = chartHeight - panelHeight;
            
            UpdatePanelPosition();
         }
      }
      else
      {
         isDragging = false;
      }
   }
   
   // 处理按钮点击
   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      if(sparam == BTN_OPEN_BUY)
      {
         OpenPosition(ORDER_TYPE_BUY);
         ObjectSetInteger(0, BTN_OPEN_BUY, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_OPEN_SELL)
      {
         OpenPosition(ORDER_TYPE_SELL);
         ObjectSetInteger(0, BTN_OPEN_SELL, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_ADD_TREND)
      {
         AddPositionTrend();
         ObjectSetInteger(0, BTN_ADD_TREND, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_ADD_COUNTER)
      {
         AddPositionCounter();
         ObjectSetInteger(0, BTN_ADD_COUNTER, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_LOT_UP)
      {
         currentLotSize = NormalizeDouble(currentLotSize + InpLotStep, 2);
         if(currentLotSize > InpMaxLot)
            currentLotSize = InpMaxLot;
         UpdateLotLabel();
         ObjectSetInteger(0, BTN_LOT_UP, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_LOT_DOWN)
      {
         currentLotSize = NormalizeDouble(currentLotSize - InpLotStep, 2);
         if(currentLotSize < InpMinLot)
            currentLotSize = InpMinLot;
         UpdateLotLabel();
         ObjectSetInteger(0, BTN_LOT_DOWN, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_CLOSE_ALL)
      {
         CloseAllPositions();
         ObjectSetInteger(0, BTN_CLOSE_ALL, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_CLOSE_BUY)
      {
         ClosePositionsByType(POSITION_TYPE_BUY);
         ObjectSetInteger(0, BTN_CLOSE_BUY, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_CLOSE_SELL)
      {
         ClosePositionsByType(POSITION_TYPE_SELL);
         ObjectSetInteger(0, BTN_CLOSE_SELL, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_SET_TP)
      {
         SetFixedTakeProfit();
         ObjectSetInteger(0, BTN_SET_TP, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_SET_SL)
      {
         SetFixedStopLoss();
         ObjectSetInteger(0, BTN_SET_SL, OBJPROP_STATE, false);
      }
      else if(sparam == BTN_BREAKEVEN)
      {
         SetBreakEven();
         ObjectSetInteger(0, BTN_BREAKEVEN, OBJPROP_STATE, false);
      }
      
      ChartRedraw();
   }
}

//+------------------------------------------------------------------+
//| 创建控制面板                                                      |
//+------------------------------------------------------------------+
void CreatePanel()
{
   int btnWidth = 120;
   int btnHeight = 30;
   int smallBtn = 35;
   int spacing = 5;
   int margin = 10;
   
   CreateBackground(PANEL_BG, panelX, panelY, panelWidth, panelHeight);
   
   CreateLabel(PANEL_TITLE, panelX + 5, panelY + 5);
   ObjectSetString(0, PANEL_TITLE, OBJPROP_TEXT, "≡ 交易控制面板");
   ObjectSetInteger(0, PANEL_TITLE, OBJPROP_FONTSIZE, 10);
   ObjectSetInteger(0, PANEL_TITLE, OBJPROP_COLOR, clrWhiteSmoke);
   
   int y = panelY + 30;
   int x = panelX + margin;
   
   // 开仓按钮
   CreateButton(BTN_OPEN_BUY, "开多", x, y, btnWidth, btnHeight, InpOpenColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_OPEN_SELL, "开空", x, y, btnWidth, btnHeight, InpOpenColor);
   y += btnHeight + spacing;
   
   // 手数调节
   CreateButton(BTN_LOT_DOWN, "-", x, y, smallBtn, btnHeight, clrGray);
   CreateLabel(LABEL_LOT, x + smallBtn + 5, y + 8);
   CreateButton(BTN_LOT_UP, "+", x + smallBtn + 55, y, smallBtn, btnHeight, clrGray);
   UpdateLotLabel();
   y += btnHeight + spacing * 2;
   
   // 加仓按钮
   CreateButton(BTN_ADD_TREND, "顺势加仓", x, y, btnWidth, btnHeight, InpAddColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_ADD_COUNTER, "逆势加仓", x, y, btnWidth, btnHeight, InpAddColor);
   y += btnHeight + spacing * 2;
   
   // 平仓按钮
   CreateButton(BTN_CLOSE_ALL, "一键平仓", x, y, btnWidth, btnHeight, InpCloseColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_CLOSE_BUY, "一键平多", x, y, btnWidth, btnHeight, InpCloseColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_CLOSE_SELL, "一键平空", x, y, btnWidth, btnHeight, InpCloseColor);
   y += btnHeight + spacing * 2;
   
   // 设置按钮
   CreateButton(BTN_SET_TP, "设置止盈", x, y, btnWidth, btnHeight, InpSetColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_SET_SL, "设置止损", x, y, btnWidth, btnHeight, InpSetColor);
   y += btnHeight + spacing;
   
   CreateButton(BTN_BREAKEVEN, "一键保本", x, y, btnWidth, btnHeight, InpSetColor);
   y += btnHeight + spacing * 2;
   
   CreateLabel(LABEL_INFO, x, y);
}

//+------------------------------------------------------------------+
//| 创建背景                                                          |
//+------------------------------------------------------------------+
void CreateBackground(string name, int x, int y, int width, int height)
{
   ObjectDelete(0, name);
   ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
   ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
   ObjectSetInteger(0, name, OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clrDimGray);
   ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, name, OBJPROP_BACK, false);
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}

//+------------------------------------------------------------------+
//| 创建按钮                                                          |
//+------------------------------------------------------------------+
void CreateButton(string name, string text, int x, int y, int width, int height, color clr)
{
   ObjectDelete(0, name);
   ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
   ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_BGCOLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 9);
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}

//+------------------------------------------------------------------+
//| 创建标签                                                          |
//+------------------------------------------------------------------+
void CreateLabel(string name, int x, int y)
{
   ObjectDelete(0, name);
   ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 8);
   ObjectSetString(0, name, OBJPROP_TEXT, "");
}

//+------------------------------------------------------------------+
//| 更新面板位置                                                      |
//+------------------------------------------------------------------+
void UpdatePanelPosition()
{
   int btnWidth = 120;
   int btnHeight = 30;
   int smallBtn = 35;
   int spacing = 5;
   int margin = 10;
   
   ObjectSetInteger(0, PANEL_BG, OBJPROP_XDISTANCE, panelX);
   ObjectSetInteger(0, PANEL_BG, OBJPROP_YDISTANCE, panelY);
   
   ObjectSetInteger(0, PANEL_TITLE, OBJPROP_XDISTANCE, panelX + 5);
   ObjectSetInteger(0, PANEL_TITLE, OBJPROP_YDISTANCE, panelY + 5);
   
   int y = panelY + 30;
   int x = panelX + margin;
   
   ObjectSetInteger(0, BTN_OPEN_BUY, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_OPEN_BUY, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_OPEN_SELL, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_OPEN_SELL, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_LOT_DOWN, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_LOT_DOWN, OBJPROP_YDISTANCE, y);
   ObjectSetInteger(0, LABEL_LOT, OBJPROP_XDISTANCE, x + smallBtn + 5);
   ObjectSetInteger(0, LABEL_LOT, OBJPROP_YDISTANCE, y + 8);
   ObjectSetInteger(0, BTN_LOT_UP, OBJPROP_XDISTANCE, x + smallBtn + 55);
   ObjectSetInteger(0, BTN_LOT_UP, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing * 2;
   
   ObjectSetInteger(0, BTN_ADD_TREND, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_ADD_TREND, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_ADD_COUNTER, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_ADD_COUNTER, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing * 2;
   
   ObjectSetInteger(0, BTN_CLOSE_ALL, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_CLOSE_ALL, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_CLOSE_BUY, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_CLOSE_BUY, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_CLOSE_SELL, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_CLOSE_SELL, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing * 2;
   
   ObjectSetInteger(0, BTN_SET_TP, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_SET_TP, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_SET_SL, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_SET_SL, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing;
   
   ObjectSetInteger(0, BTN_BREAKEVEN, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, BTN_BREAKEVEN, OBJPROP_YDISTANCE, y);
   y += btnHeight + spacing * 2;
   
   ObjectSetInteger(0, LABEL_INFO, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, LABEL_INFO, OBJPROP_YDISTANCE, y);
   
   ChartRedraw();
}

//+------------------------------------------------------------------+
//| 删除面板                                                          |
//+------------------------------------------------------------------+
void DeletePanel()
{
   ObjectDelete(0, PANEL_BG);
   ObjectDelete(0, PANEL_TITLE);
   ObjectDelete(0, BTN_OPEN_BUY);
   ObjectDelete(0, BTN_OPEN_SELL);
   ObjectDelete(0, BTN_ADD_TREND);
   ObjectDelete(0, BTN_ADD_COUNTER);
   ObjectDelete(0, BTN_LOT_UP);
   ObjectDelete(0, BTN_LOT_DOWN);
   ObjectDelete(0, LABEL_LOT);
   ObjectDelete(0, BTN_CLOSE_ALL);
   ObjectDelete(0, BTN_CLOSE_BUY);
   ObjectDelete(0, BTN_CLOSE_SELL);
   ObjectDelete(0, BTN_SET_TP);
   ObjectDelete(0, BTN_SET_SL);
   ObjectDelete(0, BTN_BREAKEVEN);
   ObjectDelete(0, LABEL_INFO);
}

//+------------------------------------------------------------------+
//| 更新手数标签                                                      |
//+------------------------------------------------------------------+
void UpdateLotLabel()
{
   string lotText = StringFormat("%.2f手", currentLotSize);
   ObjectSetString(0, LABEL_LOT, OBJPROP_TEXT, lotText);
}

//+------------------------------------------------------------------+
//| 更新信息标签                                                      |
//+------------------------------------------------------------------+
void UpdateInfoLabel()
{
   int totalPos = PositionsTotal();
   int buyCount = 0, sellCount = 0;
   double totalProfit = 0.0;
   
   for(int i = 0; i < totalPos; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            if(type == POSITION_TYPE_BUY)
               buyCount++;
            else if(type == POSITION_TYPE_SELL)
               sellCount++;
            
            totalProfit += PositionGetDouble(POSITION_PROFIT) + PositionGetDouble(POSITION_SWAP);
         }
      }
   }
   
   string info = StringFormat("持仓: %d\n多:%d 空:%d\n盈亏: %.2f", 
                              buyCount + sellCount, buyCount, sellCount, totalProfit);
   
   if(InpEnableTrailing)
      info += "\n移动止盈: 开";
   
   ObjectSetString(0, LABEL_INFO, OBJPROP_TEXT, info);
}

//+------------------------------------------------------------------+
//| 开仓                                                              |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE orderType)
{
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double price = (orderType == ORDER_TYPE_BUY) ? ask : bid;
   
   double tp = 0.0, sl = 0.0;
   
   if(InpAutoSetTPSL)
   {
      if(orderType == ORDER_TYPE_BUY)
      {
         if(InpTakeProfit > 0)
            tp = NormalizeDouble(price + InpTakeProfit * _Point, _Digits);
         if(InpStopLoss > 0)
            sl = NormalizeDouble(price - InpStopLoss * _Point, _Digits);
      }
      else
      {
         if(InpTakeProfit > 0)
            tp = NormalizeDouble(price - InpTakeProfit * _Point, _Digits);
         if(InpStopLoss > 0)
            sl = NormalizeDouble(price + InpStopLoss * _Point, _Digits);
      }
   }
   
   bool result = false;
   if(orderType == ORDER_TYPE_BUY)
      result = trade.Buy(currentLotSize, _Symbol, 0, sl, tp, "面板开仓");
   else
      result = trade.Sell(currentLotSize, _Symbol, 0, sl, tp, "面板开仓");
   
   if(result)
   {
      Print("开仓成功：", (orderType == ORDER_TYPE_BUY ? "多单" : "空单"), 
            "，手数：", currentLotSize, "，价格：", price);
   }
   else
   {
      Print("开仓失败：", trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| 顺势加仓（盈利方向）                                              |
//+------------------------------------------------------------------+
void AddPositionTrend()
{
   if(!InpEnableAddPosition)
   {
      Print("加仓功能未启用");
      return;
   }
   
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   int total = PositionsTotal();
   int added = 0;
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double lots = PositionGetDouble(POSITION_VOLUME);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            // 检查是否盈利达到顺势加仓条件
            bool canAdd = false;
            if(type == POSITION_TYPE_BUY && bid > openPrice + InpTrendAddDistance * _Point)
               canAdd = true;
            else if(type == POSITION_TYPE_SELL && ask < openPrice - InpTrendAddDistance * _Point)
               canAdd = true;
            
            if(canAdd)
            {
               // 计算加仓手数
               double newLot = NormalizeDouble(lots * InpAddLotMultiplier, 2);
               if(newLot > InpMaxLot)
                  newLot = InpMaxLot;
               
               // 计算止盈止损
               double tp = 0.0, sl = 0.0;
               double price = (type == POSITION_TYPE_BUY) ? ask : bid;
               
               if(InpAutoSetTPSL)
               {
                  if(type == POSITION_TYPE_BUY)
                  {
                     if(InpTakeProfit > 0)
                        tp = NormalizeDouble(price + InpTakeProfit * _Point, _Digits);
                     if(InpStopLoss > 0)
                        sl = NormalizeDouble(price - InpStopLoss * _Point, _Digits);
                  }
                  else
                  {
                     if(InpTakeProfit > 0)
                        tp = NormalizeDouble(price - InpTakeProfit * _Point, _Digits);
                     if(InpStopLoss > 0)
                        sl = NormalizeDouble(price + InpStopLoss * _Point, _Digits);
                  }
               }
               
               // 执行加仓
               bool result = false;
               if(type == POSITION_TYPE_BUY)
                  result = trade.Buy(newLot, _Symbol, 0, sl, tp, "顺势加仓");
               else
                  result = trade.Sell(newLot, _Symbol, 0, sl, tp, "顺势加仓");
               
               if(result)
                  added++;
            }
         }
      }
   }
   
   Print("顺势加仓完成，已加仓 ", added, " 次");
}

//+------------------------------------------------------------------+
//| 逆势加仓（浮亏方向）                                              |
//+------------------------------------------------------------------+
void AddPositionCounter()
{
   if(!InpEnableAddPosition)
   {
      Print("加仓功能未启用");
      return;
   }
   
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   int total = PositionsTotal();
   int added = 0;
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double lots = PositionGetDouble(POSITION_VOLUME);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            // 检查是否浮亏达到逆势加仓条件
            bool canAdd = false;
            if(type == POSITION_TYPE_BUY && bid < openPrice - InpCounterAddDistance * _Point)
               canAdd = true;
            else if(type == POSITION_TYPE_SELL && ask > openPrice + InpCounterAddDistance * _Point)
               canAdd = true;
            
            if(canAdd)
            {
               // 计算加仓手数
               double newLot = NormalizeDouble(lots * InpAddLotMultiplier, 2);
               if(newLot > InpMaxLot)
                  newLot = InpMaxLot;
               
               // 计算止盈止损
               double tp = 0.0, sl = 0.0;
               double price = (type == POSITION_TYPE_BUY) ? ask : bid;
               
               if(InpAutoSetTPSL)
               {
                  if(type == POSITION_TYPE_BUY)
                  {
                     if(InpTakeProfit > 0)
                        tp = NormalizeDouble(price + InpTakeProfit * _Point, _Digits);
                     if(InpStopLoss > 0)
                        sl = NormalizeDouble(price - InpStopLoss * _Point, _Digits);
                  }
                  else
                  {
                     if(InpTakeProfit > 0)
                        tp = NormalizeDouble(price - InpTakeProfit * _Point, _Digits);
                     if(InpStopLoss > 0)
                        sl = NormalizeDouble(price + InpStopLoss * _Point, _Digits);
                  }
               }
               
               // 执行加仓
               bool result = false;
               if(type == POSITION_TYPE_BUY)
                  result = trade.Buy(newLot, _Symbol, 0, sl, tp, "逆势加仓");
               else
                  result = trade.Sell(newLot, _Symbol, 0, sl, tp, "逆势加仓");
               
               if(result)
                  added++;
            }
         }
      }
   }
   
   Print("逆势加仓完成，已加仓 ", added, " 次");
}

//+------------------------------------------------------------------+
//| 自动检查加仓条件（按次数限制）                                    |
//+------------------------------------------------------------------+
void CheckAutoAddPosition()
{
   // 此函数为预留接口，可根据需要实现自动加仓逻辑
   // 当前版本采用手动点击加仓按钮的方式
}

//+------------------------------------------------------------------+
//| 平所有仓位                                                        |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
   int closed = 0;
   int total = PositionsTotal();
   
   for(int i = total - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            if(trade.PositionClose(ticket))
               closed++;
         }
      }
   }
   
   Print("一键平仓完成，已平 ", closed, " 个仓位");
}

//+------------------------------------------------------------------+
//| 按类型平仓                                                        |
//+------------------------------------------------------------------+
void ClosePositionsByType(ENUM_POSITION_TYPE type)
{
   int closed = 0;
   int total = PositionsTotal();
   
   for(int i = total - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            if(posType == type)
            {
               if(trade.PositionClose(ticket))
                  closed++;
            }
         }
      }
   }
   
   string typeName = (type == POSITION_TYPE_BUY) ? "多单" : "空单";
   Print("一键平", typeName, "完成，已平 ", closed, " 个仓位");
}

//+------------------------------------------------------------------+
//| 设置固定止盈                                                      |
//+------------------------------------------------------------------+
void SetFixedTakeProfit()
{
   if(InpTakeProfit <= 0)
   {
      Print("固定止盈点数未设置或无效");
      return;
   }
   
   int modified = 0;
   int total = PositionsTotal();
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentSL = PositionGetDouble(POSITION_SL);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            double newTP = 0.0;
            if(type == POSITION_TYPE_BUY)
               newTP = NormalizeDouble(openPrice + InpTakeProfit * _Point, _Digits);
            else
               newTP = NormalizeDouble(openPrice - InpTakeProfit * _Point, _Digits);
            
            if(trade.PositionModify(ticket, currentSL, newTP))
               modified++;
         }
      }
   }
   
   Print("固定止盈设置完成，已修改 ", modified, " 个仓位，止盈点数: ", InpTakeProfit);
}

//+------------------------------------------------------------------+
//| 设置固定止损                                                      |
//+------------------------------------------------------------------+
void SetFixedStopLoss()
{
   if(InpStopLoss <= 0)
   {
      Print("固定止损点数未设置或无效");
      return;
   }
   
   int modified = 0;
   int total = PositionsTotal();
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentTP = PositionGetDouble(POSITION_TP);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            double newSL = 0.0;
            if(type == POSITION_TYPE_BUY)
               newSL = NormalizeDouble(openPrice - InpStopLoss * _Point, _Digits);
            else
               newSL = NormalizeDouble(openPrice + InpStopLoss * _Point, _Digits);
            
            if(trade.PositionModify(ticket, newSL, currentTP))
               modified++;
         }
      }
   }
   
   Print("固定止损设置完成，已修改 ", modified, " 个仓位，止损点数: ", InpStopLoss);
}

//+------------------------------------------------------------------+
//| 移动止盈                                                          |
//+------------------------------------------------------------------+
void TrailingStop()
{
   int total = PositionsTotal();
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentSL = PositionGetDouble(POSITION_SL);
            double currentTP = PositionGetDouble(POSITION_TP);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            if(type == POSITION_TYPE_BUY)
            {
               double profit = bid - openPrice;
               if(profit >= InpTrailStart * _Point)
               {
                  double newSL = NormalizeDouble(bid - InpTrailDistance * _Point, _Digits);
                  
                  if(newSL > currentSL || currentSL == 0.0)
                  {
                     trade.PositionModify(ticket, newSL, currentTP);
                  }
               }
            }
            else if(type == POSITION_TYPE_SELL)
            {
               double profit = openPrice - ask;
               if(profit >= InpTrailStart * _Point)
               {
                  double newSL = NormalizeDouble(ask + InpTrailDistance * _Point, _Digits);
                  
                  if(newSL < currentSL || currentSL == 0.0)
                  {
                     trade.PositionModify(ticket, newSL, currentTP);
                  }
               }
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 一键保本                                                          |
//+------------------------------------------------------------------+
void SetBreakEven()
{
   int modified = 0;
   int total = PositionsTotal();
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentTP = PositionGetDouble(POSITION_TP);
            ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            
            double newSL = 0.0;
            
            if(type == POSITION_TYPE_BUY)
            {
               newSL = NormalizeDouble(openPrice + InpBreakEvenPoints * _Point, _Digits);
               
               if(bid > newSL)
               {
                  if(trade.PositionModify(ticket, newSL, currentTP))
                     modified++;
               }
            }
            else if(type == POSITION_TYPE_SELL)
            {
               newSL = NormalizeDouble(openPrice - InpBreakEvenPoints * _Point, _Digits);
               
               if(ask < newSL)
               {
                  if(trade.PositionModify(ticket, newSL, currentTP))
                     modified++;
               }
            }
         }
      }
   }
   
   Print("一键保本完成，已修改 ", modified, " 个仓位，加点数: ", InpBreakEvenPoints);
}
//+------------------------------------------------------------------+