how can i make the following ea have visuals on the chart ie to show how the price is moving and at what rate :


//+------------------------------------------------------------------+
//|                                               BreakoutScalper.mq5 |
//|                        Scalper EA - trades quick price breakouts |
//+------------------------------------------------------------------+
#property copyright "Ch"
#property link      ""
#property version   "1.04"
#property strict

input double  Lots                  = 0.01;                 // Lot size
input int     PointsThreshold       = 70;                 // Move in points to trigger trade
input int     CheckInterval         = 5;                   // Seconds to check price movement
input int     TrailingStopPoints    = 60;                  // Trailing stop in points
input int     EAStartHour           = 3;                   // EA start hour (server time)
input int     EAStopHour            = 20;                  // EA stop hour (server time)
input ENUM_TIMEFRAMES PriceTF       = PERIOD_M1;           // Timeframe for reference (for convenience)
input int     TradesPerSignal       = 1;                   // Number of orders to open per breakout signal
input int     InitialStopLossPoints = 75;                 // Initial stop loss in points at trade open

//--- Global variables
datetime lastCheckTime = 0;
double   priceAtLastCheck = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   lastCheckTime = TimeCurrent();
   priceAtLastCheck = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   return(INIT_SUCCEEDED);
  }

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

//+------------------------------------------------------------------+
//| Check if current time is inside operation window                 |
//+------------------------------------------------------------------+
bool IsWithinTradingTime()
  {
   datetime now = TimeCurrent();
   MqlDateTime tm;
   TimeToStruct(now,tm);

   if(tm.hour >= EAStartHour && tm.hour < EAStopHour)
     return true;
   else
     return false;
  }

//+------------------------------------------------------------------+
//| Check if EA has any open positions on current symbol             |
//+------------------------------------------------------------------+
bool HasOpenPositions()
  {
   for(int i=0; i<PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
        {
         if(PositionGetInteger(POSITION_MAGIC) == ExpertHandle() &&
            PositionGetString(POSITION_SYMBOL) == _Symbol)
           return true; // EA has open position(s) on symbol
        }
     }
   return false; // no open position found for EA
  }

//+------------------------------------------------------------------+
//| Place buy order with initial stop loss                          |
//+------------------------------------------------------------------+
bool PlaceBuy()
  {
   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   double price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double sl_price = NormalizeDouble(price - InitialStopLossPoints*_Point, _Digits);

   if(sl_price <= 0.0)
     {
      Print("Invalid SL price calculated for buy.");
      return false;
     }

   request.action = TRADE_ACTION_DEAL;
   request.symbol = _Symbol;
   request.volume = Lots;
   request.type   = ORDER_TYPE_BUY;
   request.price  = price;
   request.sl     = sl_price;
   request.tp     = 0;
   request.deviation = 10;
   request.magic = ExpertHandle();

   if(!OrderSend(request,result))
     {
      PrintFormat("Buy order failed: %s", result.comment);
      return false;
     }
   else
     {
      PrintFormat("Buy order placed at price %.5f with SL at %.5f", price, sl_price);
      return true;
     }
  }

//+------------------------------------------------------------------+
//| Place sell order with initial stop loss                         |
//+------------------------------------------------------------------+
bool PlaceSell()
  {
   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   double price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double sl_price = NormalizeDouble(price + InitialStopLossPoints*_Point, _Digits);

   if(sl_price <= 0.0)
     {
      Print("Invalid SL price calculated for sell.");
      return false;
     }

   request.action = TRADE_ACTION_DEAL;
   request.symbol = _Symbol;
   request.volume = Lots;
   request.type   = ORDER_TYPE_SELL;
   request.price  = price;
   request.sl     = sl_price;
   request.tp     = 0;
   request.deviation = 10;
   request.magic = ExpertHandle();

   if(!OrderSend(request,result))
     {
      PrintFormat("Sell order failed: %s", result.comment);
      return false;
     }
   else
     {
      PrintFormat("Sell order placed at price %.5f with SL at %.5f", price, sl_price);
      return true;
     }
  }

//+------------------------------------------------------------------+
//| Implement trailing stop for each position                        |
//+------------------------------------------------------------------+
void ManageTrailingStop()
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong ticket=PositionGetTicket(i);
      if(PositionGetInteger(POSITION_MAGIC) != ExpertHandle())
         continue; // Only handle EA's own trades

      if(!PositionSelectByTicket(ticket))
         continue;

      ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      double position_sl = PositionGetDouble(POSITION_SL);
      double current_price = 0.0;
      double new_sl = 0.0;

      if(type == POSITION_TYPE_BUY)
        current_price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
      else if(type == POSITION_TYPE_SELL)
        current_price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      else
        continue;

      MqlTradeRequest request;
      MqlTradeResult result;
      ZeroMemory(request);
      ZeroMemory(result);

      if(type == POSITION_TYPE_BUY)
        {
         new_sl = current_price - TrailingStopPoints * _Point;
         if(position_sl < new_sl)
           {
            request.action = TRADE_ACTION_SLTP;
            request.position = ticket;
            request.sl = NormalizeDouble(new_sl, _Digits);
            request.tp = PositionGetDouble(POSITION_TP);
            if(!OrderSend(request,result))
              {
               PrintFormat("Trailing stop modification failed (buy): %s",result.comment);
              }
            else
              {
               PrintFormat("Trailing Stop moved up for Buy to %.5f", request.sl);
              }
           }
        }
      else if(type == POSITION_TYPE_SELL)
        {
         new_sl = current_price + TrailingStopPoints * _Point;
         if(position_sl > new_sl || position_sl == 0.0)
           {
            request.action = TRADE_ACTION_SLTP;
            request.position = ticket;
            request.sl = NormalizeDouble(new_sl, _Digits);
            request.tp = PositionGetDouble(POSITION_TP);
            if(!OrderSend(request,result))
              {
               PrintFormat("Trailing stop modification failed (sell): %s",result.comment);
              }
            else
              {
               PrintFormat("Trailing Stop moved down for Sell to %.5f", request.sl);
              }
           }
        }
     }
  }

//+------------------------------------------------------------------+
//| Check price speed and trade accordingly                          |
//+------------------------------------------------------------------+
void CheckAndTrade()
  {
   // Wait for all open EA trades to close before opening new trades
   if(HasOpenPositions())
      return;

   if(!IsWithinTradingTime())
      return;

   datetime now = TimeCurrent();
   double current_price = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   double points_moved = (current_price - priceAtLastCheck)/_Point;

   int time_diff = (int)(now - lastCheckTime);

   if(time_diff < CheckInterval)
      return;

   if(points_moved >= PointsThreshold)
     {
      PrintFormat("Bullish breakout detected: Moved up %.1f points in %d seconds", points_moved, time_diff);
      for(int i=0; i<TradesPerSignal; i++)
         PlaceBuy();
     }
   else if(points_moved <= -PointsThreshold)
     {
      PrintFormat("Bearish breakout detected: Moved down %.1f points in %d seconds", points_moved, time_diff);
      for(int i=0; i<TradesPerSignal; i++)
         PlaceSell();
     }

   lastCheckTime = now;
   priceAtLastCheck = current_price;
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   ManageTrailingStop();
   CheckAndTrade();
  }

//+------------------------------------------------------------------+
//| Helper: return magic number                                      |
//+------------------------------------------------------------------+
uint ExpertHandle()
  {
   return(123456);
  }