TText.cxx

Go to the documentation of this file.

// @(#)root/graf:$Id$
// Author: Nicolas Brun   12/12/94
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "TText.h"
 
#include "TROOT.h"
#include "TBuffer.h"
#include "TVirtualPad.h"
#include "TVirtualPadPainter.h"
#include "TCanvasImp.h"
#include "TMath.h"
#include "TAttMarker.h"
#include "TPoint.h"
 
#include <cwchar>
#include <cstdlib>
#include <iostream>
 
 
 
/** \class TText
\ingroup BasicGraphics
 
Base class for several text objects.
 
See TAttText for a list of text attributes or fonts,
and also for a discussion on text speed and font quality.
 
By default, the text is drawn in the pad coordinates system.
One can draw in NDC coordinates [0,1] if the function SetNDC
is called for a TText object.
 
Example:
Begin_Macro(source)
{
   TText *t = new TText(.5,.5,"Hello World !");
   t->SetTextAlign(22);
   t->SetTextColor(kRed+2);
   t->SetTextFont(43);
   t->SetTextSize(40);
   t->SetTextAngle(45);
   t->Draw();
}
End_Macro
*/
 
////////////////////////////////////////////////////////////////////////////////
/// Text normal constructor.
 
TText::TText(Double_t x, Double_t y, const char *text) : TNamed("",text), TAttText(), fWcsTitle(nullptr)
{
   fX = x;
   fY = y;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Text normal constructor.
 
TText::TText(Double_t x, Double_t y, const wchar_t *text) : TNamed(), TAttText()
{
   fX = x;
   fY = y;
   fWcsTitle = new std::wstring(text);
   SetName("");
   SetMbTitle(text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Text default destructor.
 
TText::~TText()
{
   if (fWcsTitle) delete reinterpret_cast<std::wstring *>(fWcsTitle);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor.
 
TText::TText(const TText &text) : TNamed(text), TAttText(text), TAttBBox2D(text), fWcsTitle(nullptr)
{
   text.TText::Copy(*this);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Assignment operator.
 
TText &TText::operator=(const TText &src)
{
   src.TText::Copy(*this);
   return *this;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy this text to text.
 
void TText::Copy(TObject &obj) const
{
   ((TText&)obj).fX = fX;
   ((TText&)obj).fY = fY;
   TNamed::Copy(obj);
   TAttText::Copy(((TText&)obj));
   if (((TText&)obj).fWcsTitle) {
      if (fWcsTitle) {
         *reinterpret_cast<std::wstring*>(((TText&)obj).fWcsTitle) = *reinterpret_cast<const std::wstring*>(fWcsTitle);
      } else {
        delete reinterpret_cast<std::wstring*>(((TText&)obj).fWcsTitle);
        ((TText&)obj).fWcsTitle = nullptr;
      }
   } else {
      if (fWcsTitle) {
         ((TText&)(obj)).fWcsTitle = new std::wstring(*reinterpret_cast<const std::wstring*>(fWcsTitle));
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns the text as UNICODE.
 
const void *TText::GetWcsTitle(void) const
{
   if (fWcsTitle) {
      return reinterpret_cast<std::wstring *>(fWcsTitle)->c_str();
   } else {
      return nullptr;
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from point px,py to a string.
/// The rectangle surrounding this string is evaluated.
/// If the point (px,py) is in the rectangle, the distance is set to zero.
 
Int_t TText::DistancetoPrimitive(Int_t px, Int_t py)
{
   if (!gPad) return 9999;
   Int_t ptx, pty;
 
   if (TestBit(kTextNDC)) {
      ptx = gPad->UtoAbsPixel(fX);
      pty = gPad->VtoAbsPixel(fY);
   } else {
      ptx = gPad->XtoAbsPixel(gPad->XtoPad(fX));
      pty = gPad->YtoAbsPixel(gPad->YtoPad(fY));
   }
 
   // Get the text control box
   Int_t cBoxX[5], cBoxY[5];
   GetControlBox(ptx, pty, -fTextAngle, cBoxX, cBoxY);
   cBoxY[4] = cBoxY[0];
   cBoxX[4] = cBoxX[0];
 
   // Check if the point (px,py) is inside the text control box
   if (TMath::IsInside(px, py, 5, cBoxX, cBoxY)){
      return 0;
   } else {
      return 9999;
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates.
 
TText *TText::DrawText(Double_t x, Double_t y, const char *text)
{
   TText *newtext = new TText(x, y, text);
   TAttText::Copy(*newtext);
   newtext->SetBit(kCanDelete);
   if (TestBit(kTextNDC)) newtext->SetNDC();
   newtext->AppendPad();
   return newtext;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates.
 
TText *TText::DrawText(Double_t x, Double_t y, const wchar_t *text)
{
   TText *newtext = new TText(x, y, text);
   TAttText::Copy(*newtext);
   newtext->SetBit(kCanDelete);
   if (TestBit(kTextNDC)) newtext->SetNDC();
   newtext->AppendPad();
   return newtext;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates in NDC.
 
TText *TText::DrawTextNDC(Double_t x, Double_t y, const char *text)
{
   TText *newtext = DrawText(x, y, text);
   newtext->SetNDC();
   return newtext;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates in NDC.
 
TText *TText::DrawTextNDC(Double_t x, Double_t y, const wchar_t *text)
{
   TText *newtext = DrawText(x, y, text);
   newtext->SetNDC();
   return newtext;
}
 
class TTextInteractive : public TVirtualPad::TInteractive {
public:
   Int_t px1 = 0, py1 = 0, pxold = 0, pyold = 0, height = 0, width = 0;
   Bool_t resize = kFALSE, turn = kFALSE, right = kFALSE;
   Double_t theta = 0;
 
   TTextInteractive(TVirtualPad &parent, Bool_t ndc, Double_t x, Double_t y, Double_t angle)
   {
      if (ndc) {
         px1 = parent.UtoAbsPixel(x);
         py1 = parent.VtoAbsPixel(y);
      } else {
         px1 = parent.XtoAbsPixel(parent.XtoPad(x));
         py1 = parent.YtoAbsPixel(parent.YtoPad(y));
      }
      theta  = angle;
   }
 
   void SelectPart(TVirtualPad &parent, Int_t part, Int_t halign, Int_t valign)
   {
      switch (part) {
      case 0:
         if (halign == 3) {
            turn = kTRUE;
            right = kTRUE;
            parent.SetCursor(kRotate);
         } else {
            resize = kTRUE;
            height = valign;
            width = halign;
            parent.SetCursor(kArrowVer);
         }
         break;
      case 1: parent.SetCursor(kMove); break;
      case 2:
         if (halign == 3) {
            resize = kTRUE;
            height = valign;
            width = halign;
            parent.SetCursor(kArrowVer);
         } else {
            turn = kTRUE;
            right = kFALSE;
            parent.SetCursor(kRotate);
         }
      }
   }
 
   void ProcessMove(TVirtualPad &parent, TText *txt, Int_t px, Int_t py)
   {
      if (turn) {
         auto norm = TMath::Sqrt(1.*(py-py1)*(py-py1)+ 1.*(px-px1)*(px-px1));
         if (norm > 0) {
            theta = TMath::ACos((px - px1) / norm) / TMath::Pi() * 180;
            auto dtheta = TMath::ASin((py1 - py) / norm);
            if (dtheta < 0)
               theta = -theta;
            if (right)
               theta += 180;
            if (theta < 0)
               theta += 360;
            else if (theta >= 360)
               theta -= 360;
         }
      } else if (resize) {
         Int_t valign = txt->GetTextAlign() % 10;
         Int_t h = txt->GetTextSizePixels(parent) / 2;
         Int_t w = h*strlen(txt->GetTitle()); // approximate width
         auto co = TMath::Cos(txt->GetTextAngle()/180.*TMath::Pi());
         auto si = TMath::Sin(txt->GetTextAngle()/180.*TMath::Pi());
         Int_t ax = 0, ay = 0, bx, by;
         if (width == 1) {
            switch (valign) {
            case 1:
               ax = px1;
               ay = py1;
               break;
            case 2:
               ax = px1 + Int_t(si * h / 2);
               ay = py1 + Int_t(co * h / 2);
               break;
            case 3:
               ax = px1 + Int_t(si * h * 3 / 2);
               ay = py1 + Int_t(co * h * 3 / 2);
               break;
            }
         } else if (width == 2) {
            switch (valign) {
            case 1:
               ax = px1 - Int_t(co * w / 2);
               ay = py1 + Int_t(si * w / 2);
               break;
            case 2:
               ax = px1 - Int_t(co * w / 2 + si * h / 2);
               ay = py1 + Int_t(si * w / 2 + co * h / 2);
               break;
            case 3:
               ax = px1 - Int_t(co * w / 2 + si * h * 3 / 2);
               ay = py1 + Int_t(si * w / 2 + co * h * 3 / 2);
               break;
            }
         } else if (width == 3) {
            switch (valign) {
            case 1:
               ax = px1 - Int_t(co * w);
               ay = py1 + Int_t(si * w);
               break;
            case 2:
               ax = px1 - Int_t(co * w + si * h / 2);
               ay = py1 + Int_t(si * w + co * h / 2);
               break;
            case 3:
               ax = px1 - Int_t(co * w + si * h * 3 / 2);
               ay = py1 + Int_t(si * w + co * h * 3 / 2);
               break;
            }
         }
         if (height == 3) {
            bx = ax - Int_t(si*h);
            by = ay - Int_t(co*h);
         } else {
            bx = ax;
            by = ay;
         }
         Int_t cx = bx+Int_t(co*w);
         Int_t cy = by-Int_t(si*w);
         Double_t lambda = Double_t(((px-bx)*(cx-bx)+(py-by)*(cy-by)))/Double_t(((cx-bx)*(cx-bx)+(cy-by)*(cy-by)));
         Double_t x2 = Double_t(px) - lambda*Double_t(cx-bx)-Double_t(bx);
         Double_t y2 = Double_t(py) - lambda*Double_t(cy-by)-Double_t(by);
         Int_t Size = Int_t(TMath::Sqrt(x2*x2+y2*y2)*2);
         if (Size < 4) Size = 4;
 
         txt->SetTextSizePixels(Size);
      } else {
         px1 += px - pxold;   pxold = px;
         py1 += py - pyold;   pyold = py;
      }
   }
 
   void PaintControlBox(TVirtualPad &parent, Int_t *cBoxX, Int_t *cBoxY, Bool_t show_corner)
   {
      Double_t xx[5], yy[5];
      for(Int_t p = 0; p < 4; ++p) {
         xx[p] = parent.AbsPixeltoX(cBoxX[p]);
         yy[p] = parent.AbsPixeltoY(cBoxY[p]);
      }
      xx[4] = xx[0];
      yy[4] = yy[0];
      parent.PaintPolyLine(5, xx, yy, "itextbox");
 
      if (show_corner) {
         Double_t mX = parent.AbsPixeltoX(px1);
         Double_t mY = parent.AbsPixeltoY(py1);
         parent.PaintPolyMarker(1, &mX, &mY, "iftextcorner");
      }
   }
 
};
 
////////////////////////////////////////////////////////////////////////////////
/// Execute action corresponding to one event.
///
///  This member function must be implemented to realize the action
///  corresponding to the mouse click on the object in the window
 
void TText::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   if (!gPad || !gPad->IsEditable())
      return;
 
   auto &parent = *gPad;
 
   Short_t halign = GetTextAlign() / 10;
   Short_t valign = GetTextAlign() % 10;
   Bool_t opaque  = parent.OpaqueMoving();
 
   auto inter = parent.GetInteractive<TTextInteractive>(this);
 
   switch (event) {
 
   case kArrowKeyPress:
   case kButton1Down:
   case kMouseMotion: {
      inter = parent.MakeInteractive<TTextInteractive>(this, parent, TestBit(kTextNDC), GetX(), GetY(), GetTextAngle());
      inter->pxold  = px;
      inter->pyold  = py;
      auto co = TMath::Cos(GetTextAngle()/180.*TMath::Pi());
      auto si = TMath::Sin(GetTextAngle()/180.*TMath::Pi());
      Int_t cBoxX[4], cBoxY[4];
      GetControlBox(inter->px1, inter->py1, -inter->theta, cBoxX, cBoxY);
      auto div = ((cBoxX[3]-cBoxX[0])*co-(cBoxY[3]-cBoxY[0])*si);
      Int_t part = TMath::Abs(div) < 1e-8 ? 0 : (Int_t)(3 * ((px - cBoxX[0]) * co - (py - cBoxY[0]) * si) / div);
      inter->SelectPart(parent, part, halign, valign);
      break;
   }
 
   case kArrowKeyRelease:
   case kButton1Motion:
      if (!inter)
         return;
 
      inter->ProcessMove(parent, this, px, py);
 
      if (opaque) {
         SetX(GetXCoord(inter->px1, TestBit(kTextNDC), kTRUE));
         SetY(GetYCoord(inter->py1, TestBit(kTextNDC), kTRUE));
         SetTextAngle(inter->theta);
         if (inter->resize)
            parent.ShowGuidelines(this, event, 't', false);
         if (!inter->resize && !inter->turn)
            parent.ShowGuidelines(this, event, 'i', true);
         parent.Modified();
      } else {
         Int_t cBoxX[4], cBoxY[4];
         GetControlBox(inter->px1, inter->py1, -inter->theta, cBoxX, cBoxY);
         inter->PaintControlBox(parent, cBoxX, cBoxY, (halign != 2) || (valign != 2));
      }
      parent.UpdateAsync();
      break;
 
   case kButton1Up:
      if (opaque) {
         parent.ShowGuidelines(this, event);
      } else {
         SetX(GetXCoord(inter->px1, TestBit(kTextNDC), kTRUE));
         SetY(GetYCoord(inter->py1, TestBit(kTextNDC), kTRUE));
         SetTextAngle(inter->theta);
      }
      parent.Modified(kTRUE);
      parent.FreeInteractive(this);
      break;
 
   case kButton1Locate:
      ExecuteEvent(kButton1Down, px, py);
 
      while (1) {
         px = py = 0;
         event = parent.GetCanvasImp()->RequestLocator(px, py);
 
         ExecuteEvent(kButton1Motion, px, py);
 
         if (event != -1) {                     // button is released
            ExecuteEvent(kButton1Up, px, py);
            return;
         }
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the text control box. The text position coordinates is (x,y) and
/// the text angle is theta. The control box coordinates are returned in cBoxX
/// and cBoxY.
 
void TText::GetControlBox(Int_t x, Int_t y, Double_t theta,
                          Int_t cBoxX[4], Int_t cBoxY[4])
{
   Short_t halign = fTextAlign/10;          // horizontal alignment
   Short_t valign = fTextAlign - 10*halign; // vertical alignment
   UInt_t cBoxW = 0, cBoxH = 0;                     // control box width and heigh
   UInt_t Dx = 0, Dy = 0;                   // delta along x and y to align the box
 
   if (gPad) {
      Double_t tsize = GetTextSizePixels(*gPad);
      auto pp = gPad->GetPainter();
      if (pp)
         pp->GetTextExtent(GetTextFont(), tsize, cBoxW, cBoxH, GetTitle());
   }
 
   // compute the translations (Dx, Dy) required by the alignments
   switch (halign) {
      case 1 : Dx = 0      ; break;
      case 2 : Dx = cBoxW/2; break;
      case 3 : Dx = cBoxW  ; break;
   }
   switch (valign) {
      case 1 : Dy = 0      ; break;
      case 2 : Dy = cBoxH/2; break;
      case 3 : Dy = cBoxH  ; break;
   }
 
   // compute the control box coordinates before rotation
   cBoxX[0] = x-Dx;
   cBoxY[0] = y+Dy;
   cBoxX[1] = x-Dx;
   cBoxY[1] = y-cBoxH+Dy;
   cBoxX[2] = x+cBoxW-Dx;
   cBoxY[2] = y-cBoxH+Dy;
   cBoxX[3] = x+cBoxW-Dx;
   cBoxY[3] = y+Dy;
 
   // rotate the control box if needed
   if (theta) {
      Double_t cosTheta = TMath::Cos(theta*0.017453293);
      Double_t sinTheta = TMath::Sin(theta*0.017453293);
      for (int i=0; i<4 ; i++) {
         Int_t hcBoxX = cBoxX[i];
         Int_t hcBoxY = cBoxY[i];
         cBoxX[i] = (Int_t)((hcBoxX-x)*cosTheta-(hcBoxY-y)*sinTheta+x);
         cBoxY[i] = (Int_t)((hcBoxX-x)*sinTheta+(hcBoxY-y)*cosTheta+y);
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return text size in pixels. By default the size returned does not take
/// into account the text angle (angle = kFALSE). If angle is set to kTRUE
/// w and h take the angle into account.
 
void TText::GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle)
{
   const char *text = GetTitle();
   if (!text[0]) {
      w = h = 0;
      return;
   }
 
   if (!gPad)
      return;
   if (angle) {
      Int_t cBoxX[4], cBoxY[4];
      Int_t ptx, pty;
      if (TestBit(kTextNDC)) {
         ptx = gPad->UtoAbsPixel(fX);
         pty = gPad->VtoAbsPixel(fY);
      } else {
         ptx = gPad->XtoAbsPixel(gPad->XtoPad(fX));
         pty = gPad->YtoAbsPixel(gPad->YtoPad(fY));
      }
      GetControlBox(ptx, pty, fTextAngle, cBoxX, cBoxY);
      Int_t x1 = cBoxX[0];
      Int_t x2 = cBoxX[0];
      Int_t y1 = cBoxY[0];
      Int_t y2 = cBoxY[0];
      for (Int_t i=1; i<4; i++) {
         if (cBoxX[i] < x1) x1 = cBoxX[i];
         if (cBoxX[i] > x2) x2 = cBoxX[i];
         if (cBoxY[i] < y1) y1 = cBoxY[i];
         if (cBoxY[i] > y2) y2 = cBoxY[i];
      }
      w = x2 - x1;
      h = y2 - y1;
   } else {
      Double_t tsize = GetTextSizePixels(*gPad);
      auto pp = gPad->GetPainter();
      if (pp)
         pp->GetTextExtent(GetTextFont(), tsize, w, h, GetTitle());
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return text ascent and descent for string text
///  - in a return total text ascent
///  - in d return text descent
 
void TText::GetTextAscentDescent(UInt_t &a, UInt_t &d, const char *text) const
{
   if (!gPad)
      return;
 
   Double_t tsize = GetTextSizePixels(*gPad);
 
   auto pp = gPad->GetPainter();
   if (pp)
      pp->GetTextAscentDescent(GetTextFont(), tsize, a, d, text);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return text ascent and descent for string text
///  - in a return total text ascent
///  - in d return text descent
 
void TText::GetTextAscentDescent(UInt_t &a, UInt_t &d, const wchar_t *text) const
{
   if (!gPad)
      return;
 
   Double_t tsize = GetTextSizePixels(*gPad);
 
   auto pp = gPad->GetPainter();
   if (pp)
      pp->GetTextAscentDescent(GetTextFont(), tsize, a, d, text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return text extent for string text
///  - in w return total text width
///  - in h return text height
 
void TText::GetTextExtent(UInt_t &w, UInt_t &h, const char *text) const
{
   if (!gPad)
      return;
 
   Double_t tsize = GetTextSizePixels(*gPad);
 
   auto pp = gPad->GetPainter();
   if (pp)
      pp->GetTextExtent(GetTextFont(), tsize, w, h, text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return text advance for string text
/// if kern is true (default) kerning is taken into account. If it is false
/// the kerning is not taken into account.
 
void TText::GetTextAdvance(UInt_t &a, const char *text, const Bool_t kern) const
{
   if (!gPad)
      return;
 
   Double_t tsize = GetTextSizePixels(*gPad);
 
   auto pp = gPad->GetPainter();
   if (pp)
      a = pp->GetTextAdvance(GetTextFont(), tsize, text, kern);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return text extent for string text
///  - in w return total text width
///  - in h return text height
 
void TText::GetTextExtent(UInt_t &w, UInt_t &h, const wchar_t *text) const
{
   if (!gPad)
      return;
 
   Double_t tsize = GetTextSizePixels(*gPad);
 
   auto pp = gPad->GetPainter();
   if (pp)
      pp->GetTextExtent(GetTextFont(), tsize, w, h, text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// List this text with its attributes.
 
void TText::ls(Option_t *) const
{
   TROOT::IndentLevel();
   printf("Text  X=%f Y=%f Text=%s\n",fX,fY,GetTitle());
}
 
////////////////////////////////////////////////////////////////////////////////
/// Paint this text with its current attributes.
 
void TText::Paint(Option_t *)
{
   if (!gPad) return;
   TAttText::Modify();  //Change text attributes only if necessary
   if (TestBit(kTextNDC)) gPad->PaintTextNDC(fX,fY,GetTitle());
   else                   gPad->PaintText(gPad->XtoPad(fX),gPad->YtoPad(fY),GetTitle());
}
 
////////////////////////////////////////////////////////////////////////////////
/// Paint the text control box. (x,y) are the coordinates where the control
/// box should be painted and theta is the angle of the box.
 
void TText::PaintControlBox(Int_t x, Int_t y, Double_t theta)
{
   Int_t cBoxX[4], cBoxY[4];
   Short_t halign = fTextAlign/10;               // horizontal alignment
   Short_t valign = fTextAlign - 10*halign;      // vertical alignment
 
   GetControlBox(x, y, theta, cBoxX, cBoxY);
 
   auto pp = gPad->GetPainter();
   if (!pp)
      return;
 
   // Draw the text control box outline
   pp->SetAttLine({(Style_t)1, 1, 1});
   for (int p1 = 0; p1 < 4; ++p1) {
      int p2 = (p1 + 1) % 4;
      pp->DrawLine(gPad->AbsPixeltoX(cBoxX[p1]),
                   gPad->AbsPixeltoY(cBoxY[p1]),
                   gPad->AbsPixeltoX(cBoxX[p2]),
                   gPad->AbsPixeltoY(cBoxY[p2]));
   }
 
   // Draw a symbol at the text starting point
   TPoint p;
   Int_t ix = 0, iy = 0;
   switch (halign) {
      case 1 :
         switch (valign) {
            case 1 : ix = 0 ; iy = 0 ; break;
            case 2 : ix = 0 ; iy = 1 ; break;
            case 3 : ix = 1 ; iy = 1 ; break;
         }
      break;
      case 2 :
         switch (valign) {
            case 1 : ix = 0 ; iy = 3 ; break;
            case 2 : ix = 0 ; iy = 2 ; break;
            case 3 : ix = 1 ; iy = 2 ; break;
         }
      break;
      case 3 :
         switch (valign) {
            case 1 : ix = 3 ; iy = 3 ; break;
            case 2 : ix = 2 ; iy = 3 ; break;
            case 3 : ix = 2 ; iy = 2 ; break;
         }
      break;
   }
   Double_t mX = gPad->AbsPixeltoX((cBoxX[ix]+cBoxX[iy])/2);
   Double_t mY = gPad->AbsPixeltoY((cBoxY[ix]+cBoxY[iy])/2);
   pp->SetAttMarker({(Color_t)1, 24, 0.7});
   pp->DrawPolyMarker(1, &mX, &mY);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates.
 
void TText::PaintText(Double_t x, Double_t y, const char *text)
{
   TAttText::Modify();  //Change text attributes only if necessary
   if (gPad) gPad->PaintText(x,y,text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates.
 
void TText::PaintText(Double_t x, Double_t y, const wchar_t *text)
{
   TAttText::Modify();  //Change text attributes only if necessary
   if (gPad) gPad->PaintText(x,y,text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates in NDC.
 
void TText::PaintTextNDC(Double_t u, Double_t v, const char *text)
{
   TAttText::Modify();  //Change text attributes only if necessary
   if (gPad) gPad->PaintTextNDC(u,v,text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this text with new coordinates in NDC.
 
void TText::PaintTextNDC(Double_t u, Double_t v, const wchar_t *text)
{
   TAttText::Modify();  //Change text attributes only if necessary
   if (gPad) gPad->PaintTextNDC(u,v,text);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Dump this text with its attributes.
 
void TText::Print(Option_t *) const
{
   printf("Text  X=%f Y=%f Text=%s Font=%d Size=%f",fX,fY,GetTitle(),GetTextFont(),GetTextSize());
   if (GetTextColor() != 1 ) printf(" Color=%d",GetTextColor());
   if (GetTextAlign() != 10) printf(" Align=%d",GetTextAlign());
   if (GetTextAngle() != 0 ) printf(" Angle=%f",GetTextAngle());
   printf("\n");
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save primitive as a C++ statement(s) on output stream out
 
void TText::SavePrimitive(std::ostream &out, Option_t *option)
{
   SavePrimitiveConstructor(
      out, Class(), "text",
      TString::Format("%g, %g, \"%s\"", fX, fY, TString(GetTitle()).ReplaceSpecialCppChars().Data()), kFALSE);
 
   SaveTextAttributes(out, "text", 11, 0, 1, 62, 0.05);
 
   if (TestBit(kTextNDC))
      out << "   text->SetNDC();\n";
 
   SavePrimitiveDraw(out, "text", option);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set NDC mode on if isNDC = kTRUE, off otherwise
 
void TText::SetNDC(Bool_t isNDC)
{
   SetBit(kTextNDC, isNDC);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Change (i.e. set) the title of the TNamed.
 
void TText::SetMbTitle(const wchar_t *title)
{
   char *mb_title = new char[MB_CUR_MAX * wcslen(title) + 1]();
   char *p = mb_title;
   size_t length = wcslen(title);
   for (size_t i = 0; i < length; i++) {
      const int n = wctomb(p, title[i]);
      if (n >= 0) p += n;
   }
   fTitle = mb_title;
   delete [] mb_title;
   if (gPad && TestBit(kMustCleanup)) gPad->Modified();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Stream an object of class TText.
 
void TText::Streamer(TBuffer &R__b)
{
   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 1) {
         R__b.ReadClassBuffer(TText::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TNamed::Streamer(R__b);
      TAttText::Streamer(R__b);
      Float_t x,y;
      R__b >> x; fX = x;
      R__b >> y; fY = y;
      //====end of old versions
 
   } else {
      R__b.WriteClassBuffer(TText::Class(),this);
   }
}
////////////////////////////////////////////////////////////////////////////////
/// Return the "bounding Box" of the Box
 
Rectangle_t TText::GetBBox()
{
   Rectangle_t bbox{0, 0, 0, 0};
   if (gPad) {
      UInt_t w, h;
      Int_t Dx = 0, Dy = 0;
      GetBoundingBox(w, h, false);
 
      Short_t halign = fTextAlign / 10;
      Short_t valign = fTextAlign - 10 * halign;
 
      switch (halign) {
      case 1: Dx = 0; break;
      case 2: Dx = w / 2; break;
      case 3: Dx = w; break;
      }
 
      switch (valign) {
      case 1: Dy = h; break;
      case 2: Dy = h / 2; break;
      case 3: Dy = 0; break;
      }
      if (TestBit(kTextNDC)) {
         bbox.fX = gPad->UtoPixel(GetX()) - Dx;
         bbox.fY = gPad->VtoPixel(GetY()) - Dy;
      } else {
         bbox.fX = gPad->XtoPixel(gPad->XtoPad(GetX())) - Dx;
         bbox.fY = gPad->YtoPixel(gPad->YtoPad(GetY())) - Dy;
      }
      bbox.fWidth = w;
      bbox.fHeight = h;
   }
   return bbox;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the point given by Alignment as 'center'
 
TPoint TText::GetBBoxCenter()
{
   TPoint p(0, 0);
   if (gPad) {
      if (TestBit(kTextNDC)) {
         p.SetX(gPad->UtoPixel(GetX()));
         p.SetY(gPad->VtoPixel(GetY()));
      } else {
         p.SetX(gPad->XtoPixel(gPad->XtoPad(GetX())));
         p.SetY(gPad->YtoPixel(gPad->YtoPad(GetY())));
      }
   }
   return p;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set X coordinate of the point given by Alignment as 'center'
 
void TText::SetBBoxCenterX(const Int_t x)
{
   SetX(GetXCoord(x, TestBit(kTextNDC)));
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set Y coordinate of the point given by Alignment as 'center'
 
void TText::SetBBoxCenterY(const Int_t y)
{
   SetY(GetYCoord(y, TestBit(kTextNDC)));
}