Logo ROOT  
Reference Guide
TCurlyLine.cxx
Go to the documentation of this file.
1 // @(#)root/graf:$Id$
2 // Author: Otto Schaile 20/11/99
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 /** \class TCurlyLine
13 \ingroup BasicGraphics
14 
15 Implements curly or wavy polylines used to draw Feynman diagrams.
16 
17 Amplitudes and wavelengths may be specified in the constructors,
18 via commands or interactively from popup menus.
19 The class make use of TPolyLine by inheritance, ExecuteEvent methods
20 are highly inspired from the methods used in TPolyLine and TArc.
21 The picture below has been generated by the tutorial feynman.
22 
23 Begin_Macro(source)
24 ../../../tutorials/graphics/feynman.C
25 End_Macro
26 */
27 
28 #include "TCurlyLine.h"
29 #include "TROOT.h"
30 #include "TVirtualPad.h"
31 #include "TVirtualX.h"
32 #include "TMath.h"
33 #include "TPoint.h"
34 
35 #include <iostream>
36 
40 
42 
43 ////////////////////////////////////////////////////////////////////////////////
44 /// Default constructor.
45 
47 {
48  fX1 = 0.;
49  fY1 = 0.;
50  fX2 = 0.;
51  fY2 = 0.;
52  fWaveLength = 0.;
53  fAmplitude = 0.;
55  fNsteps = 0;
56 }
57 
58 ////////////////////////////////////////////////////////////////////////////////
59 /// Create a new TCurlyLine with starting point (x1, y1), end point (x2,y2).
60 /// The wavelength and amplitude are given in percent of the pad height.
61 
63 {
64  fX1 = x1;
65  fY1 = y1;
66  fX2 = x2;
67  fY2 = y2;
68  fWaveLength = wl;
69  fAmplitude = amp;
71  Build();
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Create a curly (Gluon) or wavy (Gamma) line.
76 
78 {
79  Double_t pixeltoX = 1;
80  Double_t pixeltoY = 1;
81 
82  Double_t wavelengthPix,amplitudePix, lengthPix, hPix;
83  Double_t px1, py1, px2, py2;
84  if (gPad) {
85  Double_t ww = (Double_t)gPad->GetWw();
86  Double_t wh = (Double_t)gPad->GetWh();
87  Double_t pxrange = gPad->GetAbsWNDC()*ww;
88  Double_t pyrange = - gPad->GetAbsHNDC()*wh;
89  Double_t xrange = gPad->GetX2() - gPad->GetX1();
90  Double_t yrange = gPad->GetY2() - gPad->GetY1();
91  pixeltoX = xrange / pxrange;
92  pixeltoY = yrange/pyrange;
93  hPix = TMath::Max(gPad->GetAbsHNDC() * gPad->GetWh(), gPad->GetAbsWNDC() * gPad->GetWw());
94  px1 = gPad->XtoAbsPixel(fX1);
95  py1 = gPad->YtoAbsPixel(fY1);
96  px2 = gPad->XtoAbsPixel(fX2);
97  py2 = gPad->YtoAbsPixel(fY2);
98 
99  lengthPix = TMath::Sqrt((px2-px1)*(px2-px1) + (py1-py2)*(py1-py2));
100  wavelengthPix = hPix*fWaveLength;
101  amplitudePix = hPix*fAmplitude;
102  } else {
103  wavelengthPix = fWaveLength;
104  amplitudePix = fAmplitude;
105  px1 = fX1;
106  py1 = fY1;
107  px2 = fX2;
108  py2 = fY2;
109  lengthPix = TMath::Sqrt((px2-px1)*(px2-px1) + (py1-py2)*(py1-py2));
110  }
111  // construct the curly / wavy line in pixel coordinates at angle 0
112  Double_t anglestep = 40;
113  Double_t phimaxle = TMath::Pi() * 2. / anglestep ;
114  Double_t dx = wavelengthPix / 40;
115  Double_t len2pi = dx * anglestep;
116 
117  // make sure there is a piece of straight line a both ends
118 
119  Double_t lengthcycle = 0.5 * len2pi + 2 * amplitudePix;
120  // if (fIsCurly) lengthcycle += amplitudePix;
121  Int_t nperiods = (Int_t)((lengthPix - lengthcycle) / len2pi);
122  Double_t restlength = 0.5 * (lengthPix - nperiods * len2pi - lengthcycle);
123  fNsteps = (Int_t)(anglestep * nperiods + anglestep / 2 + 4);
124  if (fNsteps < 2) fNsteps = 2;
126  Double_t *xv = GetX();
127  Double_t *yv = GetY();
128  xv[0] = 0; yv[0] = 0;
129  xv[1] = restlength; yv[1] = 0;
130  Double_t phase = 1.5 * TMath::Pi();
131  Double_t x0 = amplitudePix + restlength;
132  Int_t i;
133  for(i = 2; i < fNsteps-1; i++){
134  // distinguish between curly and wavy
135  if (fIsCurly) xv[i] = x0 + amplitudePix * TMath::Sin(phase);
136  else xv[i] = x0;
137  yv[i] = amplitudePix*TMath::Cos(phase);
138  phase += phimaxle;
139  x0 += dx;
140  }
141  xv[fNsteps-1] = lengthPix; yv[fNsteps-1] = 0;
142 
143  if (InheritsFrom("TCurlyArc")) return; // called by TCurlyArc
144 
145  // rotate object and transform back to user coordinates
146  Double_t angle = TMath::ATan2(py2-py1, px2-px1);
147  if (angle < 0) angle += 2*TMath::Pi();
148 
149  Double_t cosang = TMath::Cos(angle);
150  Double_t sinang = TMath::Sin(angle);
151  Double_t xx, yy;
152 
153  for(i = 0; i < fNsteps; i++){
154  xx = xv[i] * cosang - yv[i] * sinang;
155  yy = xv[i] * sinang + yv[i] * cosang;
156  if (gPad) {
157  xx *= pixeltoX;
158  yy *= pixeltoY;
159  }
160  xv[i] = xx + fX1;
161  yv[i] = yy + fY1;
162  }
163  if (gPad) gPad->Modified();
164 }
165 
166 ////////////////////////////////////////////////////////////////////////////////
167 /// Compute distance from point px,py to a line.
168 
170 {
171  return DistancetoLine(px,py,fX1,fY1,fX2,fY2);
172 }
173 
174 ////////////////////////////////////////////////////////////////////////////////
175 /// Execute action corresponding to one event.
176 ///
177 /// This member function is called when a TCurlyLine is clicked with the locator
178 ///
179 /// If Left button clicked on one of the line end points, this point
180 /// follows the cursor until button is released.
181 ///
182 /// if Middle button clicked, the line is moved parallel to itself
183 /// until the button is released.
184 
186 {
187  if (!gPad) return;
188 
189  Int_t kMaxDiff = 20;
190  static Int_t d1,d2,px1,px2,py1,py2;
191  static Int_t pxold, pyold, px1old, py1old, px2old, py2old;
192  static Bool_t p1, p2, pL;
193  Int_t dx, dy;
194 
195  Bool_t opaque = gPad->OpaqueMoving();
196 
197  switch (event) {
198 
199  case kArrowKeyPress:
200  case kButton1Down:
201  if (!opaque) {
202  gVirtualX->SetLineColor(-1);
203  TAttLine::Modify(); //Change line attributes only if necessary
204  }
205 
206  // No break !!!
207 
208  case kMouseMotion:
209 
210  px1 = gPad->XtoAbsPixel(fX1);
211  py1 = gPad->YtoAbsPixel(fY1);
212  px2 = gPad->XtoAbsPixel(fX2);
213  py2 = gPad->YtoAbsPixel(fY2);
214 
215  p1 = p2 = pL = kFALSE;
216 
217  d1 = TMath::Abs(px1 - px) + TMath::Abs(py1-py); //simply take sum of pixels differences
218  if (d1 < kMaxDiff) { //*-*================>OK take point number 1
219  px1old = px1; py1old = py1;
220  p1 = kTRUE;
221  gPad->SetCursor(kPointer);
222  return;
223  }
224  d2 = TMath::Abs(px2 - px) + TMath::Abs(py2-py); //simply take sum of pixels differences
225  if (d2 < kMaxDiff) { //*-*================>OK take point number 2
226  px2old = px2; py2old = py2;
227  p2 = kTRUE;
228  gPad->SetCursor(kPointer);
229  return;
230  }
231 
232  pL = kTRUE;
233  pxold = px; pyold = py;
234  gPad->SetCursor(kMove);
235 
236  break;
237 
238  case kArrowKeyRelease:
239  case kButton1Motion:
240 
241  if (p1) {
242  if (!opaque) {
243  gVirtualX->DrawLine(px1old, py1old, px2, py2);
244  gVirtualX->DrawLine(px, py, px2, py2);
245  }
246  else this->SetStartPoint(gPad->AbsPixeltoX(px),gPad->AbsPixeltoY(py));
247  px1old = px;
248  py1old = py;
249  }
250  if (p2) {
251  if (!opaque) {
252  gVirtualX->DrawLine(px1, py1, px2old, py2old);
253  gVirtualX->DrawLine(px1, py1, px, py);
254  }
255  else this->SetEndPoint(gPad->AbsPixeltoX(px), gPad->AbsPixeltoY(py));
256  px2old = px;
257  py2old = py;
258  }
259  if (pL) {
260  if (!opaque) gVirtualX->DrawLine(px1, py1, px2, py2);
261  dx = px-pxold; dy = py-pyold;
262  px1 += dx; py1 += dy; px2 += dx; py2 += dy;
263  if (!opaque) gVirtualX->DrawLine(px1, py1, px2, py2);
264  pxold = px;
265  pyold = py;
266  if (opaque) {
267  this->SetStartPoint(gPad->AbsPixeltoX(px1),gPad->AbsPixeltoY(py1));
268  this->SetEndPoint(gPad->AbsPixeltoX(px2), gPad->AbsPixeltoY(py2));
269  }
270  }
271 
272  if (opaque) {
273  if (p1) {
274  //check in which corner the BBox is edited
275  if (fX1>fX2) {
276  if (fY1>fY2)
277  gPad->ShowGuidelines(this, event, '2', true);
278  else
279  gPad->ShowGuidelines(this, event, '3', true);
280  }
281  else {
282  if (fY1>fY2)
283  gPad->ShowGuidelines(this, event, '1', true);
284  else
285  gPad->ShowGuidelines(this, event, '4', true);
286  }
287  }
288  if (p2) {
289  //check in which corner the BBox is edited
290  if (fX1>fX2) {
291  if (fY1>fY2)
292  gPad->ShowGuidelines(this, event, '4', true);
293  else
294  gPad->ShowGuidelines(this, event, '1', true);
295  }
296  else {
297  if (fY1>fY2)
298  gPad->ShowGuidelines(this, event, '3', true);
299  else
300  gPad->ShowGuidelines(this, event, '2', true);
301  }
302  }
303  if (pL) {
304  gPad->ShowGuidelines(this, event, 'i', true);
305  }
306  gPad->Modified(kTRUE);
307  gPad->Update();
308  }
309  break;
310 
311  case kButton1Up:
312 
313  if (opaque) {
314  gPad->ShowGuidelines(this, event);
315  } else {
316  if (p1) {
317  fX1 = gPad->AbsPixeltoX(px);
318  fY1 = gPad->AbsPixeltoY(py);
319  }
320  if (p2) {
321  fX2 = gPad->AbsPixeltoX(px);
322  fY2 = gPad->AbsPixeltoY(py);
323  }
324  if (pL) {
325  fX1 = gPad->AbsPixeltoX(px1);
326  fY1 = gPad->AbsPixeltoY(py1);
327  fX2 = gPad->AbsPixeltoX(px2);
328  fY2 = gPad->AbsPixeltoY(py2);
329  }
330  }
331  Build();
332  gPad->Modified();
333  if (!opaque) gVirtualX->SetLineColor(-1);
334  }
335 }
336 
337 ////////////////////////////////////////////////////////////////////////////////
338 /// Save primitive as a C++ statement(s) on output stream out
339 
340 void TCurlyLine::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
341 {
342  if (gROOT->ClassSaved(TCurlyLine::Class())) {
343  out<<" ";
344  } else {
345  out<<" TCurlyLine *";
346  }
347  out<<"curlyline = new TCurlyLine("
348  <<fX1<<","<<fY1<<","<<fX2<<","<<fY2<<","
349  <<fWaveLength<<","<<fAmplitude<<");"<<std::endl;
350  if (!fIsCurly) {
351  out<<" curlyline->SetWavy();"<<std::endl;
352  }
353  SaveLineAttributes(out,"curlyline",1,1,1);
354  out<<" curlyline->Draw();"<<std::endl;
355 }
356 
357 ////////////////////////////////////////////////////////////////////////////////
358 /// Set curly.
359 
361 {
362  fIsCurly = kTRUE;
363  Build();
364 }
365 
366 ////////////////////////////////////////////////////////////////////////////////
367 /// Set wavy.
368 
370 {
371  fIsCurly = kFALSE;
372  Build();
373 }
374 
375 ////////////////////////////////////////////////////////////////////////////////
376 /// Set wave length.
377 
379 {
380  fWaveLength = x;
381  Build();
382 }
383 
384 ////////////////////////////////////////////////////////////////////////////////
385 /// Set amplitude.
386 
388 {
389  fAmplitude = x;
390  Build();
391 }
392 
393 ////////////////////////////////////////////////////////////////////////////////
394 /// Set start point.
395 
397 {
398  fX1 = x;
399  fY1 = y;
400  Build();
401 }
402 
403 ////////////////////////////////////////////////////////////////////////////////
404 /// Set end point.
405 
407 {
408  fX2 = x;
409  fY2 = y;
410  Build();
411 }
412 
413 ////////////////////////////////////////////////////////////////////////////////
414 /// Set default wave length.
415 
417 {
418  fgDefaultWaveLength = WaveLength;
419 }
420 
421 ////////////////////////////////////////////////////////////////////////////////
422 /// Set default amplitude.
423 
425 {
426  fgDefaultAmplitude = Amplitude;
427 }
428 
429 ////////////////////////////////////////////////////////////////////////////////
430 /// Set default "IsCurly".
431 
433 {
434  fgDefaultIsCurly = IsCurly;
435 }
436 
437 ////////////////////////////////////////////////////////////////////////////////
438 /// Get default wave length.
439 
441 {
442  return fgDefaultWaveLength;
443 }
444 
445 ////////////////////////////////////////////////////////////////////////////////
446 /// Get default amplitude.
447 
449 {
450  return fgDefaultAmplitude;
451 }
452 
453 ////////////////////////////////////////////////////////////////////////////////
454 /// Get default "IsCurly".
455 
457 {
458  return fgDefaultIsCurly;
459 }
460 
461 ////////////////////////////////////////////////////////////////////////////////
462 /// Return the bounding Box of the CurlyLine
463 
465 {
466  Rectangle_t BBox;
467  Int_t px1, py1, px2, py2;
468  px1 = gPad->XtoPixel(fX1);
469  px2 = gPad->XtoPixel(fX2);
470  py1 = gPad->YtoPixel(fY1);
471  py2 = gPad->YtoPixel(fY2);
472 
473  Int_t tmp;
474  if (px1>px2) { tmp = px1; px1 = px2; px2 = tmp;}
475  if (py1>py2) { tmp = py1; py1 = py2; py2 = tmp;}
476 
477  BBox.fX = px1;
478  BBox.fY = py1;
479  BBox.fWidth = px2-px1;
480  BBox.fHeight = py2-py1;
481 
482  return (BBox);
483 }
484 
485 ////////////////////////////////////////////////////////////////////////////////
486 /// Return the center of the BoundingBox as TPoint in pixels
487 
489 {
490  TPoint p;
491  p.SetX(gPad->XtoPixel(TMath::Min(fX1,fX2)+0.5*(TMath::Max(fX1, fX2)-TMath::Min(fX1, fX2))));
492  p.SetY(gPad->YtoPixel(TMath::Min(fY1,fY2)+0.5*(TMath::Max(fY1, fY2)-TMath::Min(fY1, fY2))));
493  return(p);
494 }
495 
496 ////////////////////////////////////////////////////////////////////////////////
497 /// Set center of the BoundingBox
498 
500 {
503  Double_t x1, x2, y1, y2;
504 
505  if (fX2 > fX1) {
506  x1 = gPad->PixeltoX(p.GetX())-0.5*w;
507  x2 = gPad->PixeltoX(p.GetX())+0.5*w;
508  } else {
509  x2 = gPad->PixeltoX(p.GetX())-0.5*w;
510  x1 = gPad->PixeltoX(p.GetX())+0.5*w;
511  }
512  if (fY2 > fY1) {
513  y1 = gPad->PixeltoY(p.GetY()-gPad->VtoPixel(0))-0.5*h;
514  y2 = gPad->PixeltoY(p.GetY()-gPad->VtoPixel(0))+0.5*h;
515  } else {
516  y2 = gPad->PixeltoY(p.GetY()-gPad->VtoPixel(0))-0.5*h;
517  y1 = gPad->PixeltoY(p.GetY()-gPad->VtoPixel(0))+0.5*h;
518  }
519  this->SetStartPoint(x1, y1);
520  this->SetEndPoint(x2, y2);
521 }
522 
523 ////////////////////////////////////////////////////////////////////////////////
524 /// Set X coordinate of the center of the BoundingBox
525 
527 {
529  if (fX2>fX1) {
530  this->SetStartPoint(gPad->PixeltoX(x)-0.5*w, fY1);
531  this->SetEndPoint(gPad->PixeltoX(x)+0.5*w, fY2);
532  }
533  else {
534  this->SetEndPoint(gPad->PixeltoX(x)-0.5*w, fY2);
535  this->SetStartPoint(gPad->PixeltoX(x)+0.5*w, fY1);
536  }
537 }
538 
539 ////////////////////////////////////////////////////////////////////////////////
540 /// Set Y coordinate of the center of the BoundingBox
541 
543 {
545  if (fY2>fY1) {
546  this->SetStartPoint(fX1, gPad->PixeltoY(y-gPad->VtoPixel(0))-0.5*h);
547  this->SetEndPoint(fX2, gPad->PixeltoY(y-gPad->VtoPixel(0))+0.5*h);
548  }
549  else {
550  this->SetEndPoint(fX2, gPad->PixeltoY(y-gPad->VtoPixel(0))-0.5*h);
551  this->SetStartPoint(fX1, gPad->PixeltoY(y-gPad->VtoPixel(0))+0.5*h);
552  }
553 }
554 
555 ////////////////////////////////////////////////////////////////////////////////
556 /// Set left hand side of BoundingBox to a value
557 /// (resize in x direction on left)
558 
560 {
561  if (fX2>fX1)
562  this->SetStartPoint(gPad->PixeltoX(x), fY1);
563  else
564  this->SetEndPoint(gPad->PixeltoX(x), fY2);
565 }
566 
567 ////////////////////////////////////////////////////////////////////////////////
568 /// Set right hands ide of BoundingBox to a value
569 /// (resize in x direction on right)
570 
572 {
573  if (fX2>fX1)
574  this->SetEndPoint(gPad->PixeltoX(x), fY2);
575  else
576  this->SetStartPoint(gPad->PixeltoX(x), fY1);
577 }
578 
579 ////////////////////////////////////////////////////////////////////////////////
580 /// Set top of BoundingBox to a value (resize in y direction on top)
581 
583 {
584  if (fY2>fY1)
585  this->SetEndPoint(fX2, gPad->PixeltoY(y - gPad->VtoPixel(0)));
586  else
587  this->SetStartPoint(fX1, gPad->PixeltoY(y - gPad->VtoPixel(0)));
588 }
589 
590 ////////////////////////////////////////////////////////////////////////////////
591 /// Set bottom of BoundingBox to a value
592 /// (resize in y direction on bottom)
593 
595 {
596  if (fY2>fY1)
597  this->SetStartPoint(fX1, gPad->PixeltoY(y - gPad->VtoPixel(0)));
598  else
599  this->SetEndPoint(fX2, gPad->PixeltoY(y - gPad->VtoPixel(0)));
600 }
TCurlyLine::GetBBox
virtual Rectangle_t GetBBox()
Return the bounding Box of the CurlyLine.
Definition: TCurlyLine.cxx:464
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:95
TMath::ATan2
Double_t ATan2(Double_t y, Double_t x)
Definition: TMath.h:679
TCurlyLine::fY1
Double_t fY1
start y, center for arc
Definition: TCurlyLine.h:23
TCurlyLine::SetAmplitude
virtual void SetAmplitude(Double_t x)
Set amplitude.
Definition: TCurlyLine.cxx:387
TCurlyLine::SetBBoxX2
virtual void SetBBoxX2(const Int_t x)
Set right hands ide of BoundingBox to a value (resize in x direction on right)
Definition: TCurlyLine.cxx:571
Option_t
const char Option_t
Definition: RtypesCore.h:66
TCurlyLine::SetWaveLength
virtual void SetWaveLength(Double_t WaveLength)
Set wave length.
Definition: TCurlyLine.cxx:378
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TCurlyLine
Implements curly or wavy polylines used to draw Feynman diagrams.
Definition: TCurlyLine.h:19
kButton1Motion
@ kButton1Motion
Definition: Buttons.h:20
TPoint::GetX
SCoord_t GetX() const
Definition: TPoint.h:46
TMath::Cos
Double_t Cos(Double_t)
Definition: TMath.h:643
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
Rectangle_t
Rectangle structure (maps to the X11 XRectangle structure)
Definition: GuiTypes.h:361
TCurlyLine::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save primitive as a C++ statement(s) on output stream out.
Definition: TCurlyLine.cxx:340
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TPoint::GetY
SCoord_t GetY() const
Definition: TPoint.h:47
kButton1Up
@ kButton1Up
Definition: Buttons.h:19
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
TCurlyLine::fIsCurly
Bool_t fIsCurly
true: Gluon, false: Gamma
Definition: TCurlyLine.h:29
TCurlyLine::SetStartPoint
virtual void SetStartPoint(Double_t x1, Double_t y1)
Set start point.
Definition: TCurlyLine.cxx:396
Int_t
int Int_t
Definition: RtypesCore.h:45
TCurlyLine::fgDefaultAmplitude
static Double_t fgDefaultAmplitude
default amplitude
Definition: TCurlyLine.h:32
TAttLine::SaveLineAttributes
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:270
x
Double_t x[n]
Definition: legend1.C:17
TCurlyLine.h
TVirtualX.h
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
kMove
@ kMove
Definition: GuiTypes.h:374
kMouseMotion
@ kMouseMotion
Definition: Buttons.h:23
TCurlyLine::GetDefaultIsCurly
static Bool_t GetDefaultIsCurly()
Get default "IsCurly".
Definition: TCurlyLine.cxx:456
TCurlyLine::fgDefaultIsCurly
static Bool_t fgDefaultIsCurly
default curly type
Definition: TCurlyLine.h:33
TCurlyLine::SetDefaultIsCurly
static void SetDefaultIsCurly(Bool_t IsCurly)
Set default "IsCurly".
Definition: TCurlyLine.cxx:432
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
Rectangle_t::fY
Short_t fY
Definition: GuiTypes.h:362
bool
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TCurlyLine::SetBBoxCenterX
virtual void SetBBoxCenterX(const Int_t x)
Set X coordinate of the center of the BoundingBox.
Definition: TCurlyLine.cxx:526
TROOT.h
TAttLine::Modify
virtual void Modify()
Change current line attributes if necessary.
Definition: TAttLine.cxx:242
Rectangle_t::fX
Short_t fX
Definition: GuiTypes.h:362
TCurlyLine::TCurlyLine
TCurlyLine()
Default constructor.
Definition: TCurlyLine.cxx:46
TCurlyLine::fNsteps
Int_t fNsteps
used internally (controls precision)
Definition: TCurlyLine.h:28
TPolyLine::GetY
Double_t * GetY() const
Definition: TPolyLine.h:55
TMath::Pi
constexpr Double_t Pi()
Definition: TMath.h:37
TCurlyLine::SetBBoxCenter
virtual void SetBBoxCenter(const TPoint &p)
Set center of the BoundingBox.
Definition: TCurlyLine.cxx:499
TCurlyLine::fY2
Double_t fY2
end y
Definition: TCurlyLine.h:25
h
#define h(i)
Definition: RSha256.hxx:106
TCurlyLine::SetDefaultWaveLength
static void SetDefaultWaveLength(Double_t WaveLength)
Set default wave length.
Definition: TCurlyLine.cxx:416
TCurlyLine::SetBBoxCenterY
virtual void SetBBoxCenterY(const Int_t y)
Set Y coordinate of the center of the BoundingBox.
Definition: TCurlyLine.cxx:542
TCurlyLine::SetEndPoint
virtual void SetEndPoint(Double_t x2, Double_t y2)
Set end point.
Definition: TCurlyLine.cxx:406
TCurlyLine::SetCurly
virtual void SetCurly()
Set curly.
Definition: TCurlyLine.cxx:360
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:96
TCurlyLine::ExecuteEvent
void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Definition: TCurlyLine.cxx:185
TMath::Sin
Double_t Sin(Double_t)
Definition: TMath.h:639
TCurlyLine::SetDefaultAmplitude
static void SetDefaultAmplitude(Double_t Amplitude)
Set default amplitude.
Definition: TCurlyLine.cxx:424
TVirtualPad.h
TCurlyLine::GetDefaultAmplitude
static Double_t GetDefaultAmplitude()
Get default amplitude.
Definition: TCurlyLine.cxx:448
y
Double_t y[n]
Definition: legend1.C:17
kPointer
@ kPointer
Definition: GuiTypes.h:375
TCurlyLine::SetBBoxY2
virtual void SetBBoxY2(const Int_t y)
Set bottom of BoundingBox to a value (resize in y direction on bottom)
Definition: TCurlyLine.cxx:594
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
TCurlyLine::GetDefaultWaveLength
static Double_t GetDefaultWaveLength()
Get default wave length.
Definition: TCurlyLine.cxx:440
TCurlyLine::fX2
Double_t fX2
end x
Definition: TCurlyLine.h:24
kArrowKeyPress
@ kArrowKeyPress
Definition: Buttons.h:21
TCurlyLine::SetWavy
virtual void SetWavy()
Set wavy.
Definition: TCurlyLine.cxx:369
TCurlyLine::fgDefaultWaveLength
static Double_t fgDefaultWaveLength
default wavelength
Definition: TCurlyLine.h:31
TCurlyLine::GetBBoxCenter
virtual TPoint GetBBoxCenter()
Return the center of the BoundingBox as TPoint in pixels.
Definition: TCurlyLine.cxx:488
TCurlyLine::fAmplitude
Double_t fAmplitude
amplitude of sinusoid in percent of pad height
Definition: TCurlyLine.h:27
TCurlyLine::SetBBoxY1
virtual void SetBBoxY1(const Int_t y)
Set top of BoundingBox to a value (resize in y direction on top)
Definition: TCurlyLine.cxx:582
kButton1Down
@ kButton1Down
Definition: Buttons.h:17
TPoint
Definition: TPoint.h:31
Double_t
double Double_t
Definition: RtypesCore.h:59
Rectangle_t::fHeight
UShort_t fHeight
Definition: GuiTypes.h:363
TPolyLine::SetPolyLine
virtual void SetPolyLine(Int_t n)
Resize this polyline to size n.
Definition: TPolyLine.cxx:668
Rectangle_t::fWidth
UShort_t fWidth
Definition: GuiTypes.h:363
TPoint::SetY
void SetY(SCoord_t y)
Definition: TPoint.h:49
TCurlyLine::DistancetoPrimitive
Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to a line.
Definition: TCurlyLine.cxx:169
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
gPad
#define gPad
Definition: TVirtualPad.h:287
TAttLine::DistancetoLine
Int_t DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2)
Compute distance from point px,py to a line.
Definition: TAttLine.cxx:206
TCurlyLine::SetBBoxX1
virtual void SetBBoxX1(const Int_t x)
Set left hand side of BoundingBox to a value (resize in x direction on left)
Definition: TCurlyLine.cxx:559
TPoint.h
Class
void Class()
Definition: Class.C:29
TCurlyLine::fX1
Double_t fX1
start x, center for arc
Definition: TCurlyLine.h:22
kArrowKeyRelease
@ kArrowKeyRelease
Definition: Buttons.h:21
TPoint::SetX
void SetX(SCoord_t x)
Definition: TPoint.h:48
TCurlyLine::fWaveLength
Double_t fWaveLength
wavelength of sinusoid in percent of pad height
Definition: TCurlyLine.h:26
TMath.h
gROOT
#define gROOT
Definition: TROOT.h:406
int
TCurlyLine::Build
virtual void Build()
Create a curly (Gluon) or wavy (Gamma) line.
Definition: TCurlyLine.cxx:77
TPolyLine::GetX
Double_t * GetX() const
Definition: TPolyLine.h:54