Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TAxis3D.cxx
Go to the documentation of this file.
1 // @(#)root/g3d:$Id$
2 // Author: Valery Fine(fine@mail.cern.ch) 07/01/2000
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 <ctype.h>
13 #include <assert.h>
14 
15 #include "Riostream.h"
16 #include "TMath.h"
17 #include "TList.h"
18 #include "TClass.h"
19 #include "TAxis3D.h"
20 #include "TCanvas.h"
21 #include "TPad.h"
22 #include "TGaxis.h"
23 #include "TView.h"
24 #include "TVirtualPad.h"
25 #include "TVirtualX.h"
26 #include "TBrowser.h"
27 #include "TStyle.h"
28 
29 /** \class TAxis3D
30 \ingroup g3d
31 
32 The 3D axis painter class
33 
34 This class provide up to 3 axes to any 3D ROOT plot and "ZOOM" service.
35 ExecuteEvent() method does provide zooming and moving a projection
36 3D object within TPad client area. With Zoom mode on the user can access
37 TAxis3D context menu and set /change the attributes of axes all together
38 or separately.
39 
40 To add the 3D rulers to any 3D view one has to create
41 an instance of this class and Draw it.
42 
43 ~~~ {.cpp}
44  TAxis3D rulers;
45  rulers.Draw();
46 ~~~
47 
48 One can use a static method to create ruler and attach it to the current gPad
49 
50 ~~~ {.cpp}
51  TAxis3D::ToggleRulers(); // Brings the 3D axes up
52  TAxis3D::ToggleRulers(); // next calls remove the rulers from the TPad etc
53 ~~~
54 
55 To activate Zoomer one may call
56 
57 ~~~ {.cpp}
58  TAxis3D::ToggleZoom();
59 ~~~
60 
61 each time one needs move or zoom the image. Then the user can:
62 
63  - move:
64 \image html g3d_axis3d_01.png
65  - zoom:
66 \image html g3d_axis3d_02.png
67 
68 its 3D view with <left-mouse button> press / move.
69 The "Zoom" deactivates itself just the user release the <left-mouse button>
70 
71 To change attributes of the rulers attached to the current Pad, one may
72 query its pointer first:
73 
74 ~~~ {.cpp}
75 TAxis3D *axis = TAxis3D::GetPadAxis(); // Ask axis pointer
76 if (axis) {
77  TAxis3D::ToggleRulers() // To pop axes down
78  axis->SetLabelColor(kBlue); // Paint the axes labels with blue color
79  axis->SetAxisColor(kRed); // Paint the axes itself with blue color
80  TAxis3D::ToggleRulers() // To pop axes up
81 }
82 ~~~
83 
84 The attributes of the created axes are affected by the current style
85 (see TStyle class ) and Set... methods of this class
86 
87 For example:
88 ~~~ {.cpp}
89  gStyle->SetAxisColor(kYellow,"X");
90  gStyle->SetAxisColor(kYellow,"Y");
91  gStyle->SetAxisColor(kYellow,"Z");
92 
93  gStyle->SetLabelColor(kYellow,"X");
94  gStyle->SetLabelColor(kYellow,"Y");
95  gStyle->SetLabelColor(kYellow,"Z");
96 
97  TAxis3D::ToggleRulers();
98  TAxis3D::ToggleRulers();
99 ~~~
100 
101 will draw all axes and labels with yellow color.
102 */
103 
104 const Char_t *TAxis3D::fgRulerName = "axis3druler";
105 ClassImp(TAxis3D);
106 
107 ////////////////////////////////////////////////////////////////////////////////
108 /// Normal constructor.
109 
110 TAxis3D::TAxis3D() : TNamed(TAxis3D::fgRulerName,"ruler")
111 {
112  fSelected = 0;
113  fZoomMode = kFALSE;
114  fStickyZoom = kFALSE;
115  InitSet();
116 }
117 
118 ////////////////////////////////////////////////////////////////////////////////
119 /// Normal constructor.
120 
121 TAxis3D::TAxis3D(Option_t *) : TNamed(TAxis3D::fgRulerName,"ruler")
122 {
123  fSelected = 0;
124  InitSet();
125  fZoomMode = kFALSE;
126  fStickyZoom = kFALSE;
127 }
128 
129 ////////////////////////////////////////////////////////////////////////////////
130 /// Copy constructor.
131 
132 TAxis3D::TAxis3D(const TAxis3D &axis) : TNamed(axis)
133 {
134  ((TAxis3D&)axis).Copy(*this);
135 }
136 
137 ////////////////////////////////////////////////////////////////////////////////
138 /// Copy axis3d
139 
140 void TAxis3D::Copy(TObject &obj) const
141 {
142  TNamed::Copy(obj);
143  for (Int_t i=0;i<2;i++) fAxis[i].Copy(((TAxis3D&)obj).fAxis[i]);
144 }
145 
146 ////////////////////////////////////////////////////////////////////////////////
147 /// Initialization.
148 
149 void TAxis3D::InitSet()
150 {
151  fAxis[0].SetName("xaxis");
152  fAxis[1].SetName("yaxis");
153  fAxis[2].SetName("zaxis");
154 
155  fAxis[0].Set(1,0.,1.);
156  fAxis[1].Set(1,0.,1.);
157  fAxis[2].Set(1,0.,1.);
158  UseCurrentStyle();
159 }
160 
161 ////////////////////////////////////////////////////////////////////////////////
162 /// Add all 3 axes to the TBrowser
163 
164 void TAxis3D::Browse(TBrowser *b)
165 {
166  for (Int_t i=0;i<3;i++) b->Add(&fAxis[i],fAxis[i].GetTitle());
167 }
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Compute distance from point px,py to a line.
171 
172 Int_t TAxis3D::DistancetoPrimitive(Int_t px, Int_t py)
173 {
174  Int_t dist = 9;
175  for (int i=0;i<3;i++) {
176  Int_t axDist = fAxis[i].DistancetoPrimitive(px,py);
177  if (dist > axDist) { dist = axDist; fSelected = &fAxis[i]; }
178  }
179  if (fZoomMode)
180  return 0;
181  else
182  return dist;
183 }
184 
185 ////////////////////////////////////////////////////////////////////////////////
186 /// Execute action corresponding to one event.
187 ///
188 /// This member function is called when an axis is clicked with the locator
189 
190 void TAxis3D::ExecuteEvent(Int_t event, Int_t px, Int_t py)
191 {
192  if (!gPad) return;
193 
194  if (fSelected) fSelected->ExecuteEvent(event,px,py);
195 
196  // Execute action corresponding to the mouse event
197 
198  static Double_t x0, y0, x1, y1;
199 
200  static Int_t pxold, pyold;
201  static Int_t px0, py0;
202  static Int_t linedrawn;
203 
204  if (!fZoomMode) return;
205 
206  // something to zoom ?
207 
208  gPad->SetCursor(kCross);
209 
210  switch (event) {
211 
212  case kButton1Down:
213  gVirtualX->SetLineColor(-1);
214  gPad->TAttLine::Modify(); //Change line attributes only if necessary
215  ((TPad *)gPad)->AbsPixeltoXY(px,py,x0,y0);
216  px0 = px; py0 = py;
217  pxold = px; pyold = py;
218  linedrawn = 0;
219  break;
220 
221  case kButton1Motion:
222  if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
223  pxold = px;
224  pyold = py;
225  linedrawn = 1;
226  gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
227  break;
228 
229  case kButton1Up: {
230  Int_t i;
231  gPad->SetDoubleBuffer(1);
232  gVirtualX->SetDrawMode(TVirtualX::kCopy); // set drawing mode back to normal (copy) mode
233  TView *view = gPad->GetView();
234  if (!view) break; // no 3D view yet
235 
236  Double_t min[3],max[3],viewCenter[3],viewCenterNDC[3];
237 
238  view->GetRange(min,max);
239  for (i =0; i<3;i++) viewCenter[i] = (max[i]+min[i])/2;
240  view->WCtoNDC(viewCenter,viewCenterNDC);
241  // Define the center
242  Double_t center[3],pointNDC[3],size[3],oldSize[3];
243  ((TPad *)gPad)->AbsPixeltoXY(px,py,x1,y1);
244  pointNDC[0] = (x0+x1)/2; pointNDC[1] = (y0+y1)/2;
245  pointNDC[2] = viewCenterNDC[2];
246  view->NDCtoWC(pointNDC, center);
247 
248  for (i =0; i<3;i++) oldSize[i] = size[i]= (max[i]-min[i])/2;
249 
250  // If there was a small motion, move the center only, do not change a scale
251  if (TMath::Abs(px-px0)+TMath::Abs(py - py0) > 4 ) {
252  Double_t newEdge[3];
253  for (i =0; i<3;i++) size[i] = -1;
254 
255  pointNDC[0] = x0; pointNDC[1] = y0;
256 
257  view->NDCtoWC(pointNDC, newEdge);
258  for (i =0; i<3;i++) {
259  Double_t newSize = TMath::Abs(newEdge[i]-center[i]);
260  if ( newSize/oldSize[i] > 0.002)
261  size[i] = TMath::Max(size[i], newSize);
262  else
263  size[i] = oldSize[i];
264  }
265 
266  pointNDC[0] = x1; pointNDC[1] = y1;
267 
268  view->NDCtoWC(pointNDC, newEdge);
269  for (i =0; i<3;i++) {
270  Double_t newSize = TMath::Abs(newEdge[i]-center[i]);
271  if ( newSize/oldSize[i] > 0.002)
272  size[i] = TMath::Max(size[i], newSize);
273  else
274  size[i] = oldSize[i];
275  }
276 #if 0
277  if (fZooms == kMAXZOOMS) fZoom = 0;
278  fZooms++;
279  memcpy(fZoomMin[fZooms],min,3*sizeof(Float_t));
280  memcpy(fZoomMax[fZooms],max,3*sizeof(Float_t));
281 #endif
282  }
283  for (i =0; i<3;i++) {
284  max[i] = center[i] + size[i];
285  min[i] = center[i] - size[i];
286  }
287  view->SetRange(min,max);
288 
289  if(!fStickyZoom)SwitchZoom();
290  gPad->Modified(kTRUE);
291  gPad->Update();
292  break;
293  }
294  default: break;
295  }
296 }
297 
298 ////////////////////////////////////////////////////////////////////////////////
299 /// Dummy method
300 /// returns the const char * to "axis3d"
301 
302 char *TAxis3D::GetObjectInfo(Int_t , Int_t ) const
303 {
304  return (char*)"axis3d";
305 }
306 
307 ////////////////////////////////////////////////////////////////////////////////
308 /// Paint axis over 3D view on the TPad
309 
310 void TAxis3D::Paint(Option_t *)
311 {
312  TGaxis axis;
313  PaintAxis(&axis, 90);
314 }
315 
316 ////////////////////////////////////////////////////////////////////////////////
317 /// Draw the axis for TView object.
318 ///
319 /// The original idea belongs:
320 ///
321 /// void THistPainter::PaintLegoAxis(TGaxis *axis, Double_t ang)
322 
323 void TAxis3D::PaintAxis(TGaxis *axis, Float_t ang)
324 {
325  static Double_t epsil = 0.001;
326 
327  Double_t cosa, sina;
328  Double_t bmin, bmax;
329  Double_t r[24] /* was [3][8] */;
330  Int_t ndiv, i;
331  Double_t x1[3], x2[3], y1[3], y2[3], z1[3], z2[3], av[24] /* was [3][8] */;
332  char chopax[10];
333  Int_t ix1, ix2, iy1, iy2, iz1, iz2;
334  Double_t rad;
335 
336  TView *view = gPad->GetView();
337  if (!view) {
338  Error("PaintAxis", "no TView in current pad");
339  return;
340  }
341 
342  rad = TMath::ATan(1.) * 4. / 180.;
343  cosa = TMath::Cos(ang*rad);
344  sina = TMath::Sin(ang*rad);
345 
346  view->AxisVertex(ang, av, ix1, ix2, iy1, iy2, iz1, iz2);
347  for (i = 1; i <= 8; ++i) {
348  r[i*3 - 3] = av[i*3 - 3] + av[i*3 - 2]*cosa;
349  r[i*3 - 2] = av[i*3 - 2]*sina;
350  r[i*3 - 1] = av[i*3 - 1];
351  }
352 
353  view->WCtoNDC(&r[ix1*3 - 3], x1);
354  view->WCtoNDC(&r[ix2*3 - 3], x2);
355  view->WCtoNDC(&r[iy1*3 - 3], y1);
356  view->WCtoNDC(&r[iy2*3 - 3], y2);
357  view->WCtoNDC(&r[iz1*3 - 3], z1);
358  view->WCtoNDC(&r[iz2*3 - 3], z2);
359 
360  view->SetAxisNDC(x1, x2, y1, y2, z1, z2);
361 
362  Double_t *rmin = view->GetRmin();
363  Double_t *rmax = view->GetRmax();
364 
365  axis->SetLineWidth(1);
366 
367  for (i=0;i<3;i++) {
368 
369  // X axis drawing
370  Double_t ax[2], ay[2];
371  Bool_t logAx = kFALSE;
372  memset(chopax,0,sizeof(chopax));
373  switch (i) {
374  case 0 :
375  ax[0] = x1[0]; ax[1] = x2[0];
376  ay[0] = x1[1]; ay[1] = x2[1];
377  logAx = gPad->GetLogx();
378  break;
379  case 1 :
380  if (TMath::Abs(y1[0] - y2[0]) < epsil) y2[0] = y1[0];
381  ax[0] = y1[0]; ax[1] = y2[0];
382  ay[0] = y1[1]; ay[1] = y2[1];
383  logAx = gPad->GetLogy();
384  break;
385  case 2 :
386  ax[0] = z1[0]; ax[1] = z2[0];
387  ay[0] = z1[1]; ay[1] = z2[1];
388  strlcpy(chopax, "SDH+=",10);
389  logAx = gPad->GetLogz();
390  break;
391  default:
392  assert(0);
393  continue;
394  };
395 
396  // If the axis is too short - skip it
397  if ( ( TMath::Abs(ax[0] - ax[1]) + TMath::Abs(ay[0] - ay[1])) < epsil ) continue;
398 
399  if (i != 2 ) {
400  if (ax[0] > ax[1]) strlcpy(chopax, "SDHV=+",10);
401  else strlcpy(chopax, "SDHV=-",10);
402  }
403 
404  if (i==1 && (TMath::Abs(z1[0] - z2[0]) + TMath::Abs(z1[1] - z2[1])) < epsil)
405  strlcpy(chopax, "SDH+=",10);
406 
407  // Initialize the axis options
408  if (logAx) {
409  strlcat(chopax,"G",10);
410  bmin = TMath::Power(10, rmin[i]);
411  bmax = TMath::Power(10, rmax[i]);
412  } else {
413  bmin = rmin[i];
414  bmax = rmax[i];
415  }
416 
417  axis->SetLineColor( fAxis[i].GetAxisColor());
418  axis->SetTextFont( fAxis[i].GetTitleFont());
419  axis->SetTextColor( fAxis[i].GetTitleColor());
420  axis->SetTickSize( fAxis[i].GetTickLength());
421  axis->SetLabelColor( fAxis[i].GetLabelColor());
422  axis->SetLabelFont( fAxis[i].GetLabelFont());
423  axis->SetLabelOffset(fAxis[i].GetLabelOffset()+fAxis[i].GetTickLength());
424  axis->SetLabelSize( fAxis[i].GetLabelSize());
425  axis->SetTitle( fAxis[i].GetTitle());
426  axis->SetTitleOffset(fAxis[i].GetTitleOffset());
427  axis->SetTitleSize( fAxis[i].GetTitleSize());
428  enum { kCenterTitle = BIT(12) }; // to be removed with the last version of ROOT
429  axis->SetBit(kCenterTitle, fAxis[i].TestBit(kCenterTitle));
430 
431  //*-*- Initialize the number of divisions. If the
432  //*-*- number of divisions is negative, option 'N' is required.
433  ndiv = fAxis[i].GetNdivisions();
434  if (ndiv < 0) {
435  ndiv = -ndiv;
436  chopax[6] = 'N';
437  }
438 
439  // Option time display is required ?
440  if (fAxis[i].GetTimeDisplay()) {
441  strlcat(chopax,"t",10);
442  if (strlen(fAxis[i].GetTimeFormatOnly()) == 0) {
443  axis->SetTimeFormat(fAxis[i].ChooseTimeFormat(bmax-bmin));
444  } else {
445  axis->SetTimeFormat(fAxis[i].GetTimeFormat());
446  }
447  }
448  axis->SetOption(chopax);
449  axis->PaintAxis(ax[0], ay[0], ax[1], ay[1], bmin, bmax, ndiv, chopax);
450  }
451 }
452 
453 ////////////////////////////////////////////////////////////////////////////////
454 /// Convert "screen pixel" coordinates to some center of 3D WC coordinate
455 /// if view and gPad present
456 
457 Double_t *TAxis3D::PixeltoXYZ(Double_t px, Double_t py, Double_t *point3D, TView *view)
458 {
459  Double_t *thisPoint = 0;
460  if (!view && gPad) view = gPad->GetView();
461  if (view) {
462  Double_t x[3] = {px,py,0.5}; // ((TPad *)thisPad)->AbsPixeltoXY(px,py,x[0],x[1]);
463  Double_t min[3], max[3];
464  view->GetRange(min,max);
465  Int_t i;
466  for (i =0; i<3;i++) min[i] = (max[i]+min[i])/2;
467  view->WCtoNDC(min,max);
468  min[0] = x[0]; min[1] = x[1];
469  min[2] = max[2];
470  view->NDCtoWC(min, x);
471  for (i=0;i<3;i++) point3D[i] = x[i];
472  thisPoint = point3D;
473  }
474  return thisPoint;
475 }
476 
477 ////////////////////////////////////////////////////////////////////////////////
478 /// Save primitive as a C++ statement(s) on output stream out
479 
480 void TAxis3D::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
481 {
482  fAxis[0].SaveAttributes(out,GetName(),"->GetXaxis()");
483  fAxis[1].SaveAttributes(out,GetName(),"->GetYaxis()");
484  fAxis[2].SaveAttributes(out,GetName(),"->GetZaxis()");
485 }
486 
487 ////////////////////////////////////////////////////////////////////////////////
488 /// Replace current attributes by current style.
489 
490 void TAxis3D::UseCurrentStyle()
491 {
492  if (gStyle->IsReading()) {
493  fAxis[0].ResetAttAxis("X");
494  fAxis[1].ResetAttAxis("Y");
495  fAxis[2].ResetAttAxis("Z");
496 
497  fAxis[0].SetTitle("x");
498  fAxis[0].SetLabelColor(kRed); fAxis[0].SetAxisColor(kRed);
499  fAxis[1].SetLabelColor(kGreen); fAxis[1].SetAxisColor(kGreen);
500  fAxis[2].SetLabelColor(kBlue); fAxis[2].SetAxisColor(kBlue);
501  } else {
502  gStyle->SetNdivisions (fAxis[0].GetNdivisions(), "x");
503  gStyle->SetAxisColor (fAxis[0].GetAxisColor(), "x");
504  gStyle->SetLabelColor (fAxis[0].GetLabelColor(), "x");
505  gStyle->SetLabelFont (fAxis[0].GetLabelFont(), "x");
506  gStyle->SetLabelOffset(fAxis[0].GetLabelOffset(),"x");
507  gStyle->SetLabelSize (fAxis[0].GetLabelSize(), "x");
508  gStyle->SetTickLength (fAxis[0].GetTickLength(), "x");
509  gStyle->SetTitleOffset(fAxis[0].GetTitleOffset(),"x");
510  gStyle->SetTitleSize (fAxis[0].GetTitleSize(), "x");
511  gStyle->SetTitleColor (fAxis[0].GetTitleColor(), "x");
512  gStyle->SetTitleFont (fAxis[0].GetTitleFont(), "x");
513 
514  gStyle->SetNdivisions (fAxis[1].GetNdivisions(), "y");
515  gStyle->SetAxisColor (fAxis[1].GetAxisColor(), "y");
516  gStyle->SetLabelColor (fAxis[1].GetLabelColor(), "y");
517  gStyle->SetLabelFont (fAxis[1].GetLabelFont(), "y");
518  gStyle->SetLabelOffset(fAxis[1].GetLabelOffset(),"y");
519  gStyle->SetLabelSize (fAxis[1].GetLabelSize(), "y");
520  gStyle->SetTickLength (fAxis[1].GetTickLength(), "y");
521  gStyle->SetTitleOffset(fAxis[1].GetTitleOffset(),"y");
522  gStyle->SetTitleSize (fAxis[1].GetTitleSize(), "y");
523  gStyle->SetTitleColor (fAxis[1].GetTitleColor(), "y");
524  gStyle->SetTitleFont (fAxis[1].GetTitleFont(), "y");
525 
526  gStyle->SetNdivisions (fAxis[2].GetNdivisions(), "z");
527  gStyle->SetAxisColor (fAxis[2].GetAxisColor(), "z");
528  gStyle->SetLabelColor (fAxis[2].GetLabelColor(), "z");
529  gStyle->SetLabelFont (fAxis[2].GetLabelFont(), "z");
530  gStyle->SetLabelOffset(fAxis[2].GetLabelOffset(),"z");
531  gStyle->SetLabelSize (fAxis[2].GetLabelSize(), "z");
532  gStyle->SetTickLength (fAxis[2].GetTickLength(), "z");
533  gStyle->SetTitleOffset(fAxis[2].GetTitleOffset(),"z");
534  gStyle->SetTitleSize (fAxis[2].GetTitleSize(), "z");
535  gStyle->SetTitleColor (fAxis[2].GetTitleColor(), "z");
536  gStyle->SetTitleFont (fAxis[2].GetTitleFont(), "z");
537  }
538 }
539 
540 ////////////////////////////////////////////////////////////////////////////////
541 /// Return the axis index by its name
542 
543 Int_t TAxis3D::AxisChoice( Option_t *axis) const
544 {
545  char achoice = toupper(axis[0]);
546  if (achoice == 'X') return 0;
547  if (achoice == 'Y') return 1;
548  if (achoice == 'Z') return 2;
549  return -1;
550 }
551 
552 ////////////////////////////////////////////////////////////////////////////////
553 /// Get number of divisions.
554 
555 Int_t TAxis3D::GetNdivisions( Option_t *axis) const
556 {
557  Int_t ax = AxisChoice(axis);
558  if (ax < 0) return 0;
559  return fAxis[ax].GetNdivisions();
560 }
561 
562 ////////////////////////////////////////////////////////////////////////////////
563 /// Get axis color.
564 
565 Color_t TAxis3D::GetAxisColor( Option_t *axis) const
566 {
567  Int_t ax = AxisChoice(axis);
568  if (ax < 0) return 0;
569  return fAxis[ax].GetAxisColor();
570 }
571 
572 ////////////////////////////////////////////////////////////////////////////////
573 /// Get label color.
574 
575 Color_t TAxis3D::GetLabelColor( Option_t *axis) const
576 {
577  Int_t ax = AxisChoice(axis);
578  if (ax < 0) return 0;
579  return fAxis[ax].GetLabelColor();
580 }
581 
582 ////////////////////////////////////////////////////////////////////////////////
583 /// Get label font.
584 
585 Style_t TAxis3D::GetLabelFont( Option_t *axis) const
586 {
587  Int_t ax = AxisChoice(axis);
588  if (ax < 0) return 0;
589  return fAxis[ax].GetLabelFont();
590 }
591 
592 ////////////////////////////////////////////////////////////////////////////////
593 /// Get label offset.
594 
595 Float_t TAxis3D::GetLabelOffset( Option_t *axis) const
596 {
597  Int_t ax = AxisChoice(axis);
598  if (ax < 0) return 0;
599  return fAxis[ax].GetLabelOffset();
600 }
601 
602 ////////////////////////////////////////////////////////////////////////////////
603 /// Get label size.
604 
605 Float_t TAxis3D::GetLabelSize( Option_t *axis) const
606 {
607  Int_t ax = AxisChoice(axis);
608  if (ax < 0) return 0;
609  return fAxis[ax].GetLabelSize();
610 }
611 
612 ////////////////////////////////////////////////////////////////////////////////
613 /// Get tick mark length.
614 
615 Float_t TAxis3D::GetTickLength( Option_t *axis) const
616 {
617  Int_t ax = AxisChoice(axis);
618  if (ax < 0) return 0;
619  return fAxis[ax].GetTickLength();
620 }
621 
622 ////////////////////////////////////////////////////////////////////////////////
623 /// Get title offset.
624 
625 Float_t TAxis3D::GetTitleOffset( Option_t *axis) const
626 {
627  Int_t ax = AxisChoice(axis);
628  if (ax < 0) return 0;
629  return fAxis[ax].GetTitleOffset();
630 }
631 
632 ////////////////////////////////////////////////////////////////////////////////
633 
634 #define AXISCHOICE \
635  Int_t i = AxisChoice(axis); \
636  Int_t nax = 1; \
637  if (i == -1) { i = 0; nax = 3;}\
638  for (Int_t ax=i;ax<nax+i;ax++)
639 
640 ////////////////////////////////////////////////////////////////////////////////
641 /// Set number of divisions.
642 
643 void TAxis3D::SetNdivisions(Int_t n, Option_t *axis)
644 {
645  AXISCHOICE {fAxis[ax].SetNdivisions(n);}
646 }
647 
648 ////////////////////////////////////////////////////////////////////////////////
649 /// Set axis color.
650 
651 void TAxis3D::SetAxisColor(Color_t color, Option_t *axis)
652 {
653  AXISCHOICE {fAxis[ax].SetAxisColor(color);}
654 }
655 
656 ////////////////////////////////////////////////////////////////////////////////
657 /// Set axis range.
658 
659 void TAxis3D::SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis)
660 {
661  Int_t ax = AxisChoice(axis);
662  if (ax < 0) return;
663  TAxis *theAxis = &fAxis[ax];
664  Int_t bin1 = theAxis->FindBin(xmin);
665  Int_t bin2 = theAxis->FindBin(xmax);
666  theAxis->SetRange(bin1, bin2);
667 }
668 
669 ////////////////////////////////////////////////////////////////////////////////
670 /// Set label color.
671 
672 void TAxis3D::SetLabelColor(Color_t color, Option_t *axis)
673 {
674  AXISCHOICE { fAxis[ax].SetLabelColor(color); }
675 }
676 
677 ////////////////////////////////////////////////////////////////////////////////
678 /// Set label font.
679 
680 void TAxis3D::SetLabelFont(Style_t font, Option_t *axis)
681 {
682  AXISCHOICE { fAxis[ax].SetLabelFont(font); }
683 }
684 
685 ////////////////////////////////////////////////////////////////////////////////
686 /// Set label offset.
687 
688 void TAxis3D::SetLabelOffset(Float_t offset, Option_t *axis)
689 {
690  AXISCHOICE { fAxis[ax].SetLabelOffset(offset); }
691 }
692 
693 ////////////////////////////////////////////////////////////////////////////////
694 /// Set label size.
695 
696 void TAxis3D::SetLabelSize(Float_t size, Option_t *axis)
697 {
698  AXISCHOICE { fAxis[ax].SetLabelSize(size); }
699 }
700 
701 ////////////////////////////////////////////////////////////////////////////////
702 /// Set tick mark length.
703 
704 void TAxis3D::SetTickLength(Float_t length, Option_t *axis)
705 {
706  AXISCHOICE { fAxis[ax].SetTickLength(length); }
707 }
708 
709 ////////////////////////////////////////////////////////////////////////////////
710 /// Set title offset.
711 
712 void TAxis3D::SetTitleOffset(Float_t offset, Option_t *axis)
713 {
714  AXISCHOICE { fAxis[ax].SetTitleOffset(offset); }
715 }
716 #undef AXISCHOICE
717 
718 ////////////////////////////////////////////////////////////////////////////////
719 /// Returns the "pad" Axis3D object pointer if any.
720 
721 TAxis3D *TAxis3D::GetPadAxis(TVirtualPad *pad)
722 {
723  TObject *obj = 0;
724  TVirtualPad *thisPad=pad;
725  if (!thisPad) thisPad = gPad;
726  if (thisPad) {
727  // Find axis in the current thisPad
728  obj = thisPad->FindObject(TAxis3D::fgRulerName);
729  if (!(obj && obj->InheritsFrom(Class()->GetName()))) obj = 0;
730  }
731  return (TAxis3D *)obj;
732 }
733 
734 ////////////////////////////////////////////////////////////////////////////////
735 /// Turn ON / OFF the "Ruler", TAxis3D object attached
736 /// to the current pad
737 
738 TAxis3D *TAxis3D::ToggleRulers(TVirtualPad *pad)
739 {
740  TAxis3D *ax = 0;
741  TVirtualPad *thisPad=pad;
742  if (!thisPad) thisPad = gPad;
743  if (thisPad && thisPad->GetView() ) {
744  TAxis3D *a = GetPadAxis(pad);
745  if (a) delete a;
746  else {
747  ax = new TAxis3D;
748  ax->SetBit(kCanDelete);
749  ax->Draw();
750  }
751  thisPad->Modified();
752  thisPad->Update();
753  }
754  return ax;
755 }
756 
757 ////////////////////////////////////////////////////////////////////////////////
758 /// Turn ON / OFF the "Ruler" and "zoom mode" of the TAxis3D object attached
759 /// to the current pad (if pad = 0; gPad is used "by default")
760 ///
761 /// User is given a chance to either:
762 /// 1. move the center of the 3D scene at the cursor position
763 /// 2. zoom view with mouse "drugging" the bounder rectangle with "left" mouse
764 /// 3. Change the axis attributes via TContextMenu with "right mouse button click"
765 
766 TAxis3D *TAxis3D::ToggleZoom(TVirtualPad *pad)
767 {
768  TAxis3D *ax = 0;
769  TVirtualPad *thisPad=pad;
770  if (!thisPad) thisPad = gPad;
771  if (thisPad && thisPad->GetView()) {
772  // Find axis in the current thisPad
773  TList *l = thisPad->GetListOfPrimitives();
774  TObject *o = l->FindObject(TAxis3D::fgRulerName);
775  if (o && o->InheritsFrom(Class()->GetName())) { // Find axis
776  if (o != l->Last()) { // make sure the TAxis3D is the last object of the Pad.
777  l->Remove(o);
778  l->AddLast(o);
779  }
780  ax = (TAxis3D *)o;
781  } else { // There is no
782  ax = new TAxis3D;
783  ax->SetBit(kCanDelete);
784  ax->Draw();
785  }
786  ax->SwitchZoom();
787  }
788  return ax;
789 }