Logo ROOT  
Reference Guide
TMathText.cxx
Go to the documentation of this file.
1 // @(#)root/graf:$Id: TMathText.cxx $
2 // Author: Yue Shi Lai 16/10/12
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include <iostream>
13 #include "TROOT.h"
14 #include <ft2build.h>
15 #include FT_FREETYPE_H
16 #include FT_GLYPH_H
17 #include "TTF.h"
18 #include "TMathText.h"
19 #include "TMath.h"
20 #include "TVirtualPad.h"
21 #include "TVirtualPS.h"
22 #include "TVirtualX.h"
23 #include "TText.h"
24 
25 #include "../../../graf2d/mathtext/inc/mathtext.h"
26 #include "../../../graf2d/mathtext/inc/mathrender.h"
27 
28 /** \class TMathText
29 \ingroup BasicGraphics
30 
31 To draw TeX Mathematical Formula
32 
33 TMathText's purpose is to write mathematical equations, exactly as TeX would
34 do it. The syntax is the same as the TeX's one.
35 
36 The following example demonstrate how to use TMathText:
37 
38 Begin_Macro(source)
39 ../../../tutorials/graphics/tmathtext.C
40 End_Macro
41 
42 The list of all available symbols is given in the following example:
43 
44 Begin_Macro
45 ../../../tutorials/graphics/tmathtext2.C
46 End_Macro
47 
48 #### Limitation:
49 TMathText rendering is not implemented for the PDF output.
50 PostScript output should be used instead.
51 */
52 
53 const Double_t kPI = TMath::Pi();
54 
55 class TMathTextRenderer : public TText, public TAttFill,
56  public mathtext::math_text_renderer_t {
57 private:
58  TMathText *_parent;
59  float _font_size;
60  float _x0;
61  float _y0;
62  float _angle_degree;
63  float _pad_pixel_transform[6];
64  float _pad_scale;
65  float _pad_scale_x;
66  float _pad_scale_y;
67  float _pad_scale_x_relative;
68  float _pad_scale_y_relative;
69  float _current_font_size[mathtext::math_text_renderer_t::NFAMILY];
70  inline size_t root_face_number(
71  const unsigned int family, const bool serif = false) const
72  {
73  static const int precision = 2;
74 
75  if (family >= mathtext::math_text_renderer_t::
76  FAMILY_REGULAR &&
77  family <= mathtext::math_text_renderer_t::
78  FAMILY_BOLD_ITALIC) {
79  const unsigned int offset = family -
80  mathtext::math_text_renderer_t::FAMILY_REGULAR;
81  return serif ?
82  ((offset == 0 ? 13 : offset) * 10 + precision) :
83  ((offset + 4) * 10 + precision);
84  } else if (family >= mathtext::math_text_renderer_t::
85  FAMILY_STIX_REGULAR) {
86  const unsigned int offset = family -
87  mathtext::math_text_renderer_t::FAMILY_STIX_REGULAR;
88  return (offset + 16) * 10 + precision;
89  }
90 
91  return precision;
92  }
93  inline bool is_cyrillic_or_cjk(const wchar_t c) const
94  {
95  return mathtext::math_text_renderer_t::is_cyrillic(c) ||
96  mathtext::math_text_renderer_t::is_cjk(c);
97  }
98  inline size_t root_cjk_face_number(
99  const bool serif = false) const
100  {
101  return (serif ? 28 : 29) * 10 + 2;
102  }
103 protected:
104  inline mathtext::affine_transform_t
105  transform_logical_to_pixel(void) const
106  {
107  return mathtext::affine_transform_t::identity;
108  }
109  inline mathtext::affine_transform_t
110  transform_pixel_to_logical(void) const
111  {
112  return mathtext::affine_transform_t::identity;
113  }
114 public:
115  inline TMathTextRenderer(TMathText *parent)
116  : TText(), TAttFill(0, 1001),
117  _parent(parent), _font_size(0), _angle_degree(0)
118  {
119  int i;
120  _font_size = 0;
121  _x0 = 0;
122  _y0 = 0;
123  _angle_degree = 0;
124  for (i = 0; i<6; i++) _pad_pixel_transform[i] = 0;
125  _pad_scale = 0;
126  _pad_scale_x = 0;
127  _pad_scale_y = 0;
128  _pad_scale_x_relative = 0;
129  _pad_scale_y_relative = 0;
130  for (i = 0; i < mathtext::math_text_renderer_t::NFAMILY; i++) _current_font_size[i] = 0;
131  }
132  inline float
133  font_size(const unsigned int family = FAMILY_PLAIN) const
134  {
135  return _current_font_size[family];
136  }
137  inline void
138  point(const float /*x*/, const float /*y*/)
139  {
140  }
141  inline void
142  set_font_size(const float size, const unsigned int family)
143  {
144  _current_font_size[family] = size;
145  }
146  inline void
147  set_font_size(const float size)
148  {
149  _font_size = size;
150  std::fill(_current_font_size,
151  _current_font_size + NFAMILY, size);
152  }
153  inline void
154  reset_font_size(const unsigned int /*family*/)
155  {
156  }
157  inline void
158  set_parameter(const float x, const float y, const float size,
159  const float angle_degree)
160  {
161  _x0 = gPad->XtoAbsPixel(x);
162  _y0 = gPad->YtoAbsPixel(y);
163  _pad_scale_x =
164  gPad->XtoPixel(gPad->GetX2()) -
165  gPad->XtoPixel(gPad->GetX1());
166  _pad_scale_y =
167  gPad->YtoPixel(gPad->GetY1()) -
168  gPad->YtoPixel(gPad->GetY2());
169  _pad_scale = std::min(_pad_scale_x, _pad_scale_y);
170 
171  _angle_degree = angle_degree;
172 
173  const float angle_radiant = _angle_degree * (kPI / 180.0);
174 
175  // Initialize the affine transform
176  _pad_pixel_transform[0] = _pad_scale * cosf(angle_radiant);
177  _pad_pixel_transform[1] = -_pad_scale * sinf(angle_radiant);
178  _pad_pixel_transform[2] = _x0;
179  _pad_pixel_transform[3] = _pad_pixel_transform[1];
180  _pad_pixel_transform[4] = -_pad_pixel_transform[0];
181  _pad_pixel_transform[5] = _y0;
182 
183  set_font_size(size);
184  SetTextAngle(_angle_degree);
185  SetTextColor(_parent->fTextColor);
186  }
187  inline void
188  transform_pad(double &xt, double &yt,
189  const float x, const float y) const
190  {
191  xt = gPad->AbsPixeltoX(Int_t(
192  x * _pad_pixel_transform[0] +
193  y * _pad_pixel_transform[1] + _pad_pixel_transform[2]));
194  yt = gPad->AbsPixeltoY(Int_t(
195  x * _pad_pixel_transform[3] +
196  y * _pad_pixel_transform[4] + _pad_pixel_transform[5]));
197  }
198  inline void
199  filled_rectangle(const mathtext::bounding_box_t &bounding_box_0)
200  {
201  SetFillColor(_parent->fTextColor);
202  SetFillStyle(1001);
204 
205  double xt[4];
206  double yt[4];
207 
208  transform_pad(xt[0], yt[0],
209  bounding_box_0.left(),
210  bounding_box_0.bottom());
211  transform_pad(xt[1], yt[1],
212  bounding_box_0.right(),
213  bounding_box_0.bottom());
214  transform_pad(xt[2], yt[2],
215  bounding_box_0.right(),
216  bounding_box_0.top());
217  transform_pad(xt[3], yt[3],
218  bounding_box_0.left(),
219  bounding_box_0.top());
220  gPad->PaintFillArea(4, xt, yt);
221  }
222  inline void
223  rectangle(const mathtext::bounding_box_t &/*bounding_box*/)
224  {
225  }
226  inline mathtext::bounding_box_t
227  bounding_box(const wchar_t character, float &current_x,
228  const unsigned int family)
229  {
230  const size_t old_font_index = TTF::fgCurFontIdx;
231  const bool cyrillic_or_cjk = is_cyrillic_or_cjk(character);
232 
233  if (cyrillic_or_cjk) {
234  TTF::SetTextFont((Font_t) root_cjk_face_number());
235  } else {
236  TTF::SetTextFont((Font_t) root_face_number(family));
237  }
238  FT_Load_Glyph(
240  FT_Get_Char_Index(
241  TTF::fgFace[TTF::fgCurFontIdx], character),
242  FT_LOAD_NO_SCALE);
243 
244  const float scale = _current_font_size[family] /
245  TTF::fgFace[TTF::fgCurFontIdx]->units_per_EM;
246  const FT_Glyph_Metrics metrics =
247  TTF::fgFace[TTF::fgCurFontIdx]->glyph->metrics;
248  const float lower_left_x = metrics.horiBearingX;
249  const float lower_left_y =
250  metrics.horiBearingY - metrics.height;
251  const float upper_right_x =
252  metrics.horiBearingX + metrics.width;
253  const float upper_right_y = metrics.horiBearingY;
254  const float advance = metrics.horiAdvance;
255  const float margin = std::max(0.0F, lower_left_x);
256  const float italic_correction =
257  upper_right_x <= advance ? 0.0F :
258  std::max(0.0F, upper_right_x + margin - advance);
259  const mathtext::bounding_box_t ret =
260  mathtext::bounding_box_t(
261  lower_left_x, lower_left_y,
262  upper_right_x, upper_right_y,
263  advance, italic_correction) * scale;
264 
265  current_x += ret.advance();
266  TTF::fgCurFontIdx = old_font_index;
267 
268  return ret;
269  }
270  inline mathtext::bounding_box_t
271  bounding_box(const std::wstring string,
272  const unsigned int family = FAMILY_PLAIN)
273  {
274  if (TTF::fgCurFontIdx<0) return mathtext::bounding_box_t(0, 0, 0, 0, 0, 0);
275  if (string.empty() || TTF::fgFace[TTF::fgCurFontIdx] == NULL ||
276  TTF::fgFace[TTF::fgCurFontIdx]->units_per_EM == 0) {
277  return mathtext::bounding_box_t(0, 0, 0, 0, 0, 0);
278  }
279 
280  std::wstring::const_iterator iterator = string.begin();
281  float current_x = 0;
282  mathtext::bounding_box_t ret =
283  bounding_box(*iterator, current_x, family);
284 
285  ++iterator;
286  for (; iterator != string.end(); ++iterator) {
287  const mathtext::point_t position =
288  mathtext::point_t(current_x, 0);
289  const mathtext::bounding_box_t glyph_bounding_box =
290  bounding_box(*iterator, current_x, family);
291  ret = ret.merge(position + glyph_bounding_box);
292  }
293 
294  return ret;
295  }
296  inline void
297  text_raw(const float x, const float y,
298  const std::wstring string,
299  const unsigned int family = FAMILY_PLAIN)
300  {
301  SetTextFont((Font_t) root_face_number(family));
302  SetTextSize(_current_font_size[family]);
304 
305  wchar_t buf[2];
306  float advance = 0;
307 
308  buf[1] = L'\0';
309  for (std::wstring::const_iterator iterator = string.begin(); iterator != string.end(); ++iterator) {
310  buf[0] = *iterator;
311  const bool cyrillic_or_cjk = is_cyrillic_or_cjk(buf[0]);
312 
313  if (cyrillic_or_cjk) {
314  SetTextFont((Font_t) root_cjk_face_number());
316  }
317 
318  const mathtext::bounding_box_t b =
319  bounding_box(buf, family);
320  double xt;
321  double yt;
322 
323  transform_pad(xt, yt, x + advance, y);
324  gPad->PaintText(xt, yt, buf);
325  advance += b.advance();
326  if (cyrillic_or_cjk) {
327  SetTextFont((Font_t) root_face_number(family));
329  }
330  }
331  }
332  inline void
333  text_with_bounding_box(const float /*x*/, const float /*y*/,
334  const std::wstring /*string*/,
335  const unsigned int /*family = FAMILY_PLAIN*/)
336  {
337  }
338  using mathtext::math_text_renderer_t::bounding_box;
339 };
340 
342 
343 ////////////////////////////////////////////////////////////////////////////////
344 /// Default constructor.
345 
347  : TAttFill(0, 1001)
348 {
349  fRenderer = new TMathTextRenderer(this);
350 }
351 
352 ////////////////////////////////////////////////////////////////////////////////
353 /// Normal constructor.
354 
356  : TText(x, y, text), TAttFill(0, 1001)
357 {
358  fRenderer = new TMathTextRenderer(this);
359 }
360 
361 ////////////////////////////////////////////////////////////////////////////////
362 /// Destructor.
363 
365 {
366 }
367 
368 ////////////////////////////////////////////////////////////////////////////////
369 /// Copy constructor.
370 
372  : TText(text), TAttFill(text)
373 {
374  ((TMathText &)text).Copy(*this);
375  fRenderer = new TMathTextRenderer(this);
376 }
377 
378 ////////////////////////////////////////////////////////////////////////////////
379 /// Assignment operator.
380 
382 {
383  if (this != &rhs) {
384  TText::operator = (rhs);
386  }
387  return *this;
388 }
389 
390 ////////////////////////////////////////////////////////////////////////////////
391 /// Copy.
392 
393 void TMathText::Copy(TObject &obj) const
394 {
395  ((TMathText &)obj).fRenderer = fRenderer;
396  TText::Copy(obj);
397  TAttFill::Copy((TAttFill &)obj);
398 }
399 
400 ////////////////////////////////////////////////////////////////////////////////
401 /// Render the text.
402 
403 void TMathText::
404 Render(const Double_t x, const Double_t y, const Double_t size,
405  const Double_t angle, const Char_t *t, const Int_t /*length*/)
406 {
407  const mathtext::math_text_t math_text(t);
409 
410  renderer->set_parameter(x, y, size, angle);
411  renderer->text(0, 0, math_text);
412 }
413 
414 ////////////////////////////////////////////////////////////////////////////////
415 /// Get the text bounding box.
416 
417 void TMathText::
418 GetSize(Double_t &x0, Double_t &y0, Double_t &x1, Double_t &y1,
419  const Double_t size, const Double_t angle, const Char_t *t,
420  const Int_t /*length*/)
421 {
422  const mathtext::math_text_t math_text(t);
424 
425  renderer->set_parameter(0, 0, size, angle);
426 
427  const mathtext::bounding_box_t bounding_box =
428  renderer->bounding_box(math_text);
429  double x[4];
430  double y[4];
431 
432  renderer->transform_pad(
433  x[0], y[0], bounding_box.left(), bounding_box.bottom());
434  renderer->transform_pad(
435  x[1], y[1], bounding_box.right(), bounding_box.bottom());
436  renderer->transform_pad(
437  x[2], y[2], bounding_box.right(), bounding_box.top());
438  renderer->transform_pad(
439  x[3], y[3], bounding_box.left(), bounding_box.top());
440 
441  x0 = std::min(std::min(x[0], x[1]), std::min(x[2], x[3]));
442  y0 = std::min(std::min(y[0], y[1]), std::min(y[2], y[3]));
443  x1 = std::max(std::max(x[0], x[1]), std::max(x[2], x[3]));
444  y1 = std::max(std::max(y[0], y[1]), std::max(y[2], y[3]));
445 }
446 
447 ////////////////////////////////////////////////////////////////////////////////
448 /// Alignment.
449 
450 void TMathText::
452  const Double_t size, const Double_t angle,
453  const Char_t *t, const Int_t /*length*/,
454  const Short_t align)
455 {
456  const mathtext::math_text_t math_text(t);
458 
459  renderer->set_parameter(0, 0, size, angle);
460 
461  const mathtext::bounding_box_t bounding_box =
462  renderer->bounding_box(math_text);
463  float x = 0;
464  float y = 0;
465 
466  Short_t halign = align / 10;
467  Short_t valign = align - 10 * halign;
468 
469  switch(halign) {
470  case 0: x = bounding_box.left(); break;
471  case 1: x = 0; break;
472  case 2: x = bounding_box.horizontal_center(); break;
473  case 3: x = bounding_box.right(); break;
474  }
475  switch(valign) {
476  case 0: y = bounding_box.bottom(); break;
477  case 1: y = 0; break;
478  case 2: y = bounding_box.vertical_center(); break;
479  case 3: y = bounding_box.top(); break;
480  }
481  renderer->transform_pad(x0, y0, x, y);
482 }
483 
484 ////////////////////////////////////////////////////////////////////////////////
485 /// Get the text width and height.
486 
487 void TMathText::GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t /*angle*/)
488 {
489  const TString newText = GetTitle();
490  const Int_t length = newText.Length();
491  const Char_t *text = newText.Data();
492  const Double_t size = GetTextSize();
493 
494  Double_t x0;
495  Double_t y0;
496  Double_t x1;
497  Double_t y1;
498 
499  GetSize(x0, y0, x1, y1, size, 0, text, length);
500  w = (UInt_t)(TMath::Abs(gPad->XtoAbsPixel(x1) - gPad->XtoAbsPixel(x0)));
501  h = (UInt_t)(TMath::Abs(gPad->YtoAbsPixel(y0) - gPad->YtoAbsPixel(y1)));
502 }
503 
504 ////////////////////////////////////////////////////////////////////////////////
505 /// Get X size.
506 
508 {
509  const TString newText = GetTitle();
510  const Int_t length = newText.Length();
511  const Char_t *text = newText.Data();
512  const Double_t size = GetTextSize();
513  const Double_t angle = GetTextAngle();
514 
515  Double_t x0;
516  Double_t y0;
517  Double_t x1;
518  Double_t y1;
519 
520  GetSize(x0, y0, x1, y1, size, angle, text, length);
521 
522  return TMath::Abs(x1 - x0);
523 }
524 
525 ////////////////////////////////////////////////////////////////////////////////
526 /// Get Y size.
527 
529 {
530  const TString newText = GetTitle();
531  const Int_t length = newText.Length();
532  const Char_t *text = newText.Data();
533  const Double_t size = GetTextSize();
534  const Double_t angle = GetTextAngle();
535 
536  Double_t x0;
537  Double_t y0;
538  Double_t x1;
539  Double_t y1;
540 
541  GetSize(x0, y0, x1, y1, size, angle, text, length);
542 
543  return TMath::Abs(y0 - y1);
544 }
545 
546 ////////////////////////////////////////////////////////////////////////////////
547 /// Make a copy of this object with the new parameters
548 /// and copy object attributes.
549 
551 {
552  TMathText *newtext = new TMathText(x, y, text);
553  TAttText::Copy(*newtext);
554 
555  newtext->SetBit(kCanDelete);
556  if (TestBit(kTextNDC)) newtext->SetNDC();
557  newtext->AppendPad();
558 
559  return newtext;
560 }
561 
562 ////////////////////////////////////////////////////////////////////////////////
563 /// Paint text.
564 
566 {
567  Double_t xsave = fX;
568  Double_t ysave = fY;
569 
570  if (TestBit(kTextNDC)) {
571  fX = gPad->GetX1() + xsave * (gPad->GetX2() - gPad->GetX1());
572  fY = gPad->GetY1() + ysave * (gPad->GetY2() - gPad->GetY1());
574  } else {
575  PaintMathText(gPad->XtoPad(fX), gPad->YtoPad(fY),
577  }
578  fX = xsave;
579  fY = ysave;
580 }
581 
582 ////////////////////////////////////////////////////////////////////////////////
583 /// Paint text (used by Paint()).
584 
586  Double_t size, const Char_t *text1)
587 {
588  Double_t saveSize = size;
589  Int_t saveFont = fTextFont;
590  Short_t saveAlign = fTextAlign;
591 
593  if (gVirtualPS) { // Initialise TMathTextRenderer
594  if (gPad->IsBatch()) {
595  if (gVirtualPS->InheritsFrom("TImageDump")) gPad->PaintText(0, 0, "");
596  }
597  }
598 
599  // Do not use Latex if font is low precision.
600  if (fTextFont % 10 < 2) {
601  if (gVirtualX) {
602  gVirtualX->SetTextAngle(angle);
603  }
604  if (gVirtualPS) {
605  gVirtualPS->SetTextAngle(angle);
606  }
607  gPad->PaintText(x, y, text1);
608  return;
609  }
610 
611  if (fTextFont % 10 > 2) {
612  UInt_t w = TMath::Abs(gPad->XtoAbsPixel(gPad->GetX2()) -
613  gPad->XtoAbsPixel(gPad->GetX1()));
614  UInt_t h = TMath::Abs(gPad->YtoAbsPixel(gPad->GetY2()) -
615  gPad->YtoAbsPixel(gPad->GetY1()));
616  size = size / std::min(w, h);
617  SetTextFont(10 * (saveFont / 10) + 2);
618  }
619 
620  TString newText = text1;
621 
622  if (newText.Length() == 0) return;
623 
624  // Compatibility with TLatex and Latex
625  newText.ReplaceAll("\\omicron","o");
626  newText.ReplaceAll("\\Alpha","A");
627  newText.ReplaceAll("\\Beta","B");
628  newText.ReplaceAll("\\Epsilon","E");
629  newText.ReplaceAll("\\Zeta","Z");
630  newText.ReplaceAll("\\Eta","H");
631  newText.ReplaceAll("\\Iota","I");
632  newText.ReplaceAll("\\Kappa","K");
633  newText.ReplaceAll("\\Mu","M");
634  newText.ReplaceAll("\\Nu","N");
635  newText.ReplaceAll("\\Omicron","O");
636  newText.ReplaceAll("\\Rho","P");
637  newText.ReplaceAll("\\Tau","T");
638  newText.ReplaceAll("\\Chi","X");
639  newText.ReplaceAll("\\varomega","\\varpi");
640  newText.ReplaceAll("\\mbox","\\hbox");
641  newText.ReplaceAll("\\bar","\\wwbar");
642  if (newText.Contains("\\frac")) {
643  Int_t len,i1,i2;
644  TString str;
645  while (newText.Contains("\\frac")) {
646  len = newText.Length();
647  i1 = newText.Index("\\frac");
648  str = newText(i1,len).Data();
649  i2 = str.Index("}{");
650  newText.Replace(i1+i2,2," \\over ");
651  newText.Remove(i1,5);
652  }
653  }
654  if (newText.Contains("\\splitline")) {
655  Int_t len,i1,i2;
656  TString str;
657  while (newText.Contains("\\splitline")) {
658  len = newText.Length();
659  i1 = newText.Index("\\splitline");
660  str = newText(i1,len).Data();
661  i2 = str.Index("}{");
662  newText.Replace(i1+i2,2," \\atop ");
663  newText.Remove(i1,10);
664  }
665  }
666 
667  const Int_t length = newText.Length();
668  const Char_t *text = newText.Data();
669  Double_t x0;
670  Double_t y0;
671  GetAlignPoint(x0, y0, size, angle, text, length, fTextAlign);
672 
673  Render(x - x0, y - y0, size, angle, text, length);
674 
675  SetTextSize(saveSize);
676  SetTextFont(saveFont);
677  SetTextAlign(saveAlign);
678 }
679 
680 ////////////////////////////////////////////////////////////////////////////////
681 /// Save primitive as a C++ statement(s) on output stream out
682 
683 void TMathText::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
684 {
685  const char quote = '"';
686 
687  if (gROOT->ClassSaved(TMathText::Class())) {
688  out << " ";
689  } else {
690  out << " TMathText *";
691  }
692 
693  TString s = GetTitle();
694 
695  s.ReplaceAll("\\","\\\\");
696  s.ReplaceAll("\"","\\\"");
697  out << "mathtex = new TMathText("<< fX << "," << fY << ","
698  << quote << s.Data() << quote << ");" << std::endl;
699  if (TestBit(kTextNDC)) {
700  out << "mathtex->SetNDC();" << std::endl;
701  }
702 
703  SaveTextAttributes(out, "mathtex", 11, 0, 1, 42, 0.05);
704  SaveFillAttributes(out, "mathtex", 0, 1001);
705 
706  out<<" mathtex->Draw();" << std::endl;
707 }
c
#define c(i)
Definition: RSha256.hxx:101
fit1_py.fill
fill
Definition: fit1_py.py:6
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TAttFill::SetFillStyle
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition: TAttFill.h:39
make_cnn_model.metrics
metrics
Definition: make_cnn_model.py:15
Option_t
const char Option_t
Definition: RtypesCore.h:66
TText::Copy
void Copy(TObject &text) const
Copy this text to text.
Definition: TText.cxx:107
TMathText::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
Definition: TMathText.cxx:682
TAttFill::Modify
virtual void Modify()
Change current fill area attributes if necessary.
Definition: TAttFill.cxx:211
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
TText::fX
Double_t fX
X position of text (left,center,etc..)
Definition: TText.h:25
TString::Data
const char * Data() const
Definition: TString.h:369
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
TMathText::DrawMathText
TMathText * DrawMathText(Double_t x, Double_t y, const char *text)
Make a copy of this object with the new parameters and copy object attributes.
Definition: TMathText.cxx:549
TString::Replace
TString & Replace(Ssiz_t pos, Ssiz_t n, const char *s)
Definition: TString.h:682
TAttText::fTextAlign
Short_t fTextAlign
Text alignment.
Definition: TAttText.h:23
TAttText::SaveTextAttributes
virtual void SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1)
Save text attributes as C++ statement(s) on output stream out.
Definition: TAttText.cxx:344
TTF::fgCurFontIdx
static Int_t fgCurFontIdx
current font index
Definition: TTF.h:78
operator=
Binding & operator=(OUT(*fun)(void))
Definition: TRInterface_Binding.h:11
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162
Int_t
int Int_t
Definition: RtypesCore.h:45
TAttText::Copy
void Copy(TAttText &atttext) const
Copy this text attributes to a new TAttText.
Definition: TAttText.cxx:291
TTF::SetTextFont
static void SetTextFont(Font_t fontnumber)
Set specified font.
Definition: TTF.cxx:491
TMathText::fRenderer
void * fRenderer
Definition: TMathText.h:21
Font_t
short Font_t
Definition: RtypesCore.h:79
TObject::AppendPad
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:107
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TAttText::SetTextSize
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition: TAttText.h:46
x
Double_t x[n]
Definition: legend1.C:17
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
TVirtualPS.h
TVirtualX.h
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TAttText::GetTextSize
virtual Float_t GetTextSize() const
Return the text size.
Definition: TAttText.h:36
SetTextAngle
tt SetTextAngle(45)
TString
Basic string class.
Definition: TString.h:136
TAttFill::SaveFillAttributes
virtual void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition: TAttFill.cxx:234
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
text
TText * text
Definition: entrylist_figure1.C:10
b
#define b(i)
Definition: RSha256.hxx:100
TMathText::GetXsize
Double_t GetXsize(void)
Get X size.
Definition: TMathText.cxx:506
bool
TString::ReplaceAll
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
TAttText::Modify
virtual void Modify()
Change current text attributes if necessary.
Definition: TAttText.cxx:303
TMathText::Copy
void Copy(TObject &text) const
Copy.
Definition: TMathText.cxx:392
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TROOT.h
TGeant4Unit::L
static constexpr double L
Definition: TGeant4SystemOfUnits.h:117
TAttText::GetTextAngle
virtual Float_t GetTextAngle() const
Return the text angle.
Definition: TAttText.h:33
TMathText::GetAlignPoint
void GetAlignPoint(Double_t &x0, Double_t &y0, const Double_t size, const Double_t angle, const Char_t *t, const Int_t length, const Short_t align)
Alignment.
Definition: TMathText.cxx:450
TAttText::fTextColor
Color_t fTextColor
Text color.
Definition: TAttText.h:24
TTF.h
TMath::Pi
constexpr Double_t Pi()
Definition: TMath.h:37
TText::SetNDC
virtual void SetNDC(Bool_t isNDC=kTRUE)
Set NDC mode on if isNDC = kTRUE, off otherwise.
Definition: TText.cxx:813
TAttFill::Copy
void Copy(TAttFill &attfill) const
Copy this fill attributes to a new TAttFill.
Definition: TAttFill.cxx:202
TMathText::Render
void Render(const Double_t x, const Double_t y, const Double_t size, const Double_t angle, const Char_t *t, const Int_t length)
Render the text.
Definition: TMathText.cxx:403
h
#define h(i)
Definition: RSha256.hxx:106
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TString::Remove
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
TMathText::Paint
virtual void Paint(Option_t *option="")
Paint text.
Definition: TMathText.cxx:564
SetTextColor
pt SetTextColor(4)
TVirtualPad.h
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
y
Double_t y[n]
Definition: legend1.C:17
TText::fY
Double_t fY
Y position of text (left,center,etc..)
Definition: TText.h:26
Short_t
short Short_t
Definition: RtypesCore.h:39
TMathText::GetBoundingBox
void GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle=kFALSE)
Get the text width and height.
Definition: TMathText.cxx:486
TObject::kCanDelete
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:58
unsigned int
TString::Index
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
gVirtualPS
R__EXTERN TVirtualPS * gVirtualPS
Definition: TVirtualPS.h:81
TMathText::TMathTextRenderer
friend class TMathTextRenderer
Definition: TMathText.h:57
TAttText::SetTextAlign
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition: TAttText.h:41
TText
Base class for several text objects.
Definition: TText.h:22
Double_t
double Double_t
Definition: RtypesCore.h:59
TMathText::GetSize
void GetSize(Double_t &x0, Double_t &y0, Double_t &x1, Double_t &y1, const Double_t size, const Double_t angle, const Char_t *t, const Int_t length)
Get the text bounding box.
Definition: TMathText.cxx:417
TMathText::GetYsize
Double_t GetYsize(void)
Get Y size.
Definition: TMathText.cxx:527
TText::operator=
TText & operator=(const TText &src)
Assignment operator.
Definition: TText.cxx:98
TAttFill::SetFillColor
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
TMathText.h
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
kPI
const Double_t kPI
Definition: TMathText.cxx:52
TAttText::fTextFont
Font_t fTextFont
Text font.
Definition: TAttText.h:25
gPad
#define gPad
Definition: TVirtualPad.h:287
TMathText::operator=
TMathText & operator=(const TMathText &)
TMathText Painter.
Definition: TMathText.cxx:380
TMathText::PaintMathText
virtual void PaintMathText(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text)
Paint text (used by Paint()).
Definition: TMathText.cxx:584
TAttFill
Fill Area Attributes class.
Definition: TAttFill.h:19
TMathText::kTextNDC
@ kTextNDC
Definition: TMathText.h:37
SetTextFont
pt SetTextFont(42)
Class
void Class()
Definition: Class.C:29
TMathText::TMathText
TMathText(void)
Default constructor.
Definition: TMathText.cxx:345
TAttText::SetTextAngle
virtual void SetTextAngle(Float_t tangle=0)
Set the text angle.
Definition: TAttText.h:42
Char_t
char Char_t
Definition: RtypesCore.h:33
TAttText::SetTextFont
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition: TAttText.h:45
TText.h
SetTextSize
th1 SetTextSize(0.12)
TTF::fgFace
static FT_Face fgFace[kTTMaxFonts]
font face
Definition: TTF.h:82
TMathText::~TMathText
virtual ~TMathText(void)
Destructor.
Definition: TMathText.cxx:363
TMath.h
TMathText
To draw TeX Mathematical Formula.
Definition: TMathText.h:19
gROOT
#define gROOT
Definition: TROOT.h:406
int