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