DisplayController.cxx

Go to the documentation of this file.
00001 
00013 // for cfitsio
00014 #ifdef HAVE_CONFIG_H
00015 #include "config.h"
00016 #else
00017 
00018 // for truncation warning in debug mode and version
00019 #ifdef _MSC_VER
00020 #include "msdevstudio/MSconfig.h"
00021 #endif
00022 
00023 #endif // HAVE_CONFIG_H
00024 
00025 #include <iostream>
00026 #include "DisplayController.h"
00027 
00028 #include "DataRepController.h"
00029 #include "FunctionController.h"
00030 
00031 #include "axes/AxisModelLog.h"
00032 #include "axes/AxisModelLinear.h"
00033 
00034 #include "binners/BinnerAxis.h"
00035 #include "binners/BinnerAxisFactory.h"
00036 
00037 #include "datareps/DataRepException.h"
00038 #include "datareps/DataRepFactory.h"
00039 #include "datareps/FunctionRep.h"
00040 #include "datareps/LineDataRep.h"
00041 #include "datareps/TextDataRep.h"
00042 #include "datareps/StripChart.h"
00043 
00044 #include "datasrcs/DataSourceController.h"
00045 #include "datasrcs/NTuple.h"
00046 #include "datasrcs/NTupleController.h"
00047 
00048 #include "graphics/ViewBase.h"
00049 #include "graphics/ViewFactory.h"
00050 
00051 #include "plotters/PlotterException.h"
00052 #include "plotters/PlotterFactory.h"
00053 #include "plotters/TextPlotter.h"
00054 #include "plotters/XyPlotter.h"
00055 
00056 #include "projectors/BinningProjector.h"
00057 #include "projectors/NTupleProjector.h"
00058 
00059 #include "colorreps/BinToMovingBrkPt.h"
00060 #include "colorreps/BinToColorScaleMovingBrkPt.h"
00061 #include "colorreps/BinToColorFactory.h"
00062 #include "colorreps/BinToUsrDefinedScale.h"
00063 #include "reps/ColumnPointRep.h"
00064 #include "reps/LinePointRep.h"
00065 #include "reps/PointRepFactory.h"
00066 #include "reps/SymbolPointRep.h"
00067 #include "reps/TextRepBase.h"
00068 #include "reps/TextRepFactory.h"
00069 
00070 #include "transforms/TransformFactory.h"
00071 #include "transforms/XYTransform.h"
00072 
00073 #ifdef HAVE_CFITSIO
00074 #include "fits/FitsController.h"
00075 #endif
00076 
00077 #include <algorithm>
00078 
00079 #include <cassert>
00080 
00081 using std::list;
00082 using std::string;
00083 using std::swap;
00084 using std::vector;
00085 using std::find;
00086 
00087 using namespace hippodraw;
00088 
00089 DisplayController * DisplayController::s_instance = 0;
00090 
00091 DisplayController::DisplayController ( )
00092 {
00093 }
00094 
00095 DisplayController::~DisplayController ( )
00096 {
00097   DataRepController * controller = DataRepController::instance ();
00098   delete controller;
00099 }
00100 
00101 DisplayController * DisplayController::instance ( )
00102 {
00103   if ( s_instance == 0 ) {
00104     s_instance = new DisplayController ( );
00105   }
00106   return s_instance;
00107 }
00108 
00109 const vector < string > &
00110 DisplayController::
00111 getValueTransformTypes () const 
00112 {
00113 BinToColorFactory * factory = BinToColorFactory::instance ();
00114 
00115 return factory -> names ();
00116 }
00117 
00118 void
00119 DisplayController::
00120 setValueTransform ( PlotterBase * plotter, const std::string & name )
00121 {
00122   BinToColorFactory * factory = BinToColorFactory::instance ();
00123   BinToColor * model = factory -> create ( name );
00124 
00125   plotter -> setValueRep ( model );
00126 }
00127 
00128 void
00129 DisplayController::
00130 setValueTransform ( PlotterBase * plotter, int index )
00131 {
00132   BinToColorFactory * factory = BinToColorFactory::instance ();
00133   const vector < string > & names = factory -> names ();
00134   BinToColor * rep = factory -> create ( names[index] );
00135 
00136   plotter -> setValueRep ( rep );
00137 }
00138 
00139 void
00140 DisplayController::
00141 addValueTransform ( const std::string & name,
00142                     const std::vector < double > & ctrl_points )
00143 {
00144   BinToColor * model = new BinToUsrDefinedScale ( name.c_str() );
00145   model -> setControlPoints ( ctrl_points );
00146 
00147   BinToColorFactory * factory = BinToColorFactory::instance ();
00148   factory -> add ( model );
00149 }
00150 
00151 bool
00152 DisplayController::
00153 removeValueTransform ( const std::string & name )
00154 {
00155   BinToColorFactory * factory = BinToColorFactory::instance ();
00156   BinToColor * prototype = factory -> prototype ( name );
00157   bool yes = prototype -> isUserDefined ();
00158   if ( yes ) {
00159     factory -> remove ( name );
00160   }
00161 
00162   return yes;
00163 }
00164 
00165 const vector <double > &
00166 DisplayController::
00167 getValueCtrlPts ( const PlotterBase * plotter )
00168 {
00169   BinToColor * r = const_cast< BinToColor *> (plotter->getValueRep());
00170   return r -> getControlPoints ();
00171 }
00172 
00173 void
00174 DisplayController::
00175 setValueCtrlPts ( PlotterBase *plotter,
00176                   const std::vector < double > & sv)
00177 {
00178   BinToColor * r = const_cast< BinToColor *> (plotter->getValueRep());
00179   if ( r != 0 ) {
00180     r -> setControlPoints ( sv );
00181     DataRep * datarep = plotter -> selectedDataRep ();
00182     datarep -> notifyObservers ();
00183   }
00184 }
00185 
00186 void
00187 DisplayController::
00188 saveValueCtrlPts( PlotterBase *plotter,
00189                   const std::vector <double> & sv)
00190 {
00191   BinToColor * r = const_cast< BinToColor *> (plotter->getValueRep());
00192   if ( r != 0 ) {
00193     const std::string transformName = r->name();
00194     removeValueTransform(transformName);
00195     addValueTransform(transformName, sv);
00196   }
00197 }
00198 
00199 
00200 int
00201 DisplayController::
00202 getValueTransformIndex ( PlotterBase * plotter )
00203 {
00204   int index = -1;
00205   const BinToColor * rep = plotter -> getValueRep (); // return the value to color representation
00206   if ( rep != 0 ) { // may not have one.
00207     const string & name = rep -> name ();
00208     const vector < string > & names = getValueTransformTypes ();
00209     unsigned int size = names.size();
00210     for ( unsigned int i = 0; i < size; i++ ) {
00211       if ( name == names[i] ) {
00212         index = i;
00213         break;
00214       }
00215     }
00216   }
00217 
00218   return index;
00219 }
00220 
00221 bool
00222 DisplayController::
00223 hasControlPoints ( const PlotterBase * plotter ) const
00224 {
00225   bool yes = false;
00226   const BinToColor * rep = plotter -> getValueRep ();
00227   if ( rep != 0 ) { // may not have one
00228     yes = rep -> hasControlPoints ();
00229   }
00230 
00231   return yes;
00232 }
00233 
00234 bool
00235 DisplayController::
00236 isUserDefinedValueTransform ( const PlotterBase * plotter ) const
00237 {
00238   bool yes = false;
00239   const BinToColor * rep = plotter -> getValueRep ();
00240   if ( rep != 0 ) {
00241     yes = rep -> isUserDefined ();
00242   }
00243 
00244   return yes;
00245 }
00246 
00247 const vector < string > &
00248 DisplayController::
00249 getDisplayTypes () const
00250 {
00251   DataRepFactory * factory = DataRepFactory::instance ();
00252 
00253   return factory -> names ();
00254 }
00255 
00256 PlotterBase *
00257 DisplayController::
00258 createDisplay ( const std::string & name )
00259 {
00260   DataRepController * controller = DataRepController::instance ();
00261   DataRep * rep = controller -> createDataRep ( name );
00262 
00263   return createDisplay ( rep );
00264 }
00265 
00266 PlotterBase *
00267 DisplayController::
00268 createDisplay ( DataRep * rep )
00269 {
00270   bool yes = rep -> hasNTupleBindings ();
00271   if ( yes ) {
00272     string what ( "DisplayController: data rep of type " );
00273     what += rep -> name();
00274     what +="\nhas NTuple bindings.\n";
00275     what += "Can not create without them";
00276     throw DataRepException ( what );
00277   }
00278 
00279   PlotterBase * plotter = createPlotter ( rep );
00280   plotter -> addDataRep ( rep );
00281   plotter -> setAutoRanging ( true );
00282 
00283   return plotter;
00284 }
00285 
00289 PlotterBase *
00290 DisplayController::
00291 createDisplay ( const std::string & name,
00292                 const DataSource & tuple,
00293                 const std::vector< std::string > & bindings ) const
00294 {
00295   // Expansion needed by RootNTuple with multi-dimensional array
00296   tuple.expandIfNeeded(bindings);
00297 
00298   DataRepFactory * factory = DataRepFactory::instance ();
00299   DataRep * proto = factory->prototype ( name );
00300   assert ( proto != 0 );
00301 
00302   PlotterBase * plotter = createPlotter ( proto );
00303   addDataRep ( plotter, name, &tuple, bindings );
00304 #ifdef HAVE_CFITSIO
00305   if ( proto -> needsMatrixSet () ) {
00306     FitsController * controller = FitsController::instance ();
00307     controller -> checkForImage ( plotter, tuple );
00308   }
00309 #endif
00310 
00311   plotter -> autoScale ();
00312 
00313   return plotter;
00314 }
00315 
00316 NTuple *
00317 DisplayController::
00318 createNTupleDiff ( PlotterBase * plotter )
00319 {
00320   NTuple * ntuple = 0;
00321   ntuple = plotter -> createNTuple ();
00322   unsigned int size = ntuple -> rows ();
00323 
00324   vector < double > values ( size );
00325   vector < double > residuals ( size );
00326   DataRep * data1 = plotter -> getDataRep(0);
00327   DataRep * data2 = plotter -> getDataRep(1);
00328   NTuple * ntuple1 = data1 -> createNTuple();
00329   NTuple * ntuple2 = data2 -> createNTuple();
00330 
00331   vector < double > & x1 = ntuple1 -> getColumn ( 0 ); // X coordinate
00332   vector < double > & y1 = ntuple1 -> getColumn ( 1 ); // Y coordinate
00333   vector < double > & deltaX1 = ntuple1 -> getColumn (2); // Half bin width 
00334  
00335   vector < double > & x2 = ntuple2 -> getColumn ( 0 ); // X coordinate
00336   vector < double > & y2 = ntuple2 -> getColumn ( 1 ); // Y coordinate
00337   vector < double > & deltaX2 = ntuple2 -> getColumn (2); // Half bin width 
00338 
00339   vector <double> xDiff;
00340   vector <double> yDiff;
00341   vector <double> deltaXDiff;
00342   vector <double> deltaYDiff;
00343 
00344   unsigned int i = 0;
00345   unsigned int j = 0;
00346   while( i < x1.size() && j < x2.size() ) {  // Compare of two histogram 
00347     if (x1[i] + deltaX1[i] == x2[j] + deltaX2[j]) {
00348       if ( xDiff.empty()) {
00349         xDiff.push_back(x1[i]);
00350         yDiff.push_back(y2[j] - y1[i]);
00351         deltaXDiff.push_back(deltaX1[i]);
00352         i++; 
00353         j++; 
00354         continue;
00355       } else {
00356         double tmpX = xDiff.back();
00357         double tmpDeltaX = deltaXDiff.back();
00358         double xLeft = tmpX + tmpDeltaX;
00359         double xRight = x1[i] + deltaX1[i];
00360         xDiff.push_back(xLeft+0.5*(xRight - xLeft));
00361         yDiff.push_back(y2[j] - y1[i]);
00362         deltaXDiff.push_back(0.5*(xRight - xLeft));
00363         i++; 
00364         j++; 
00365         continue;
00366       }  
00367     } 
00368     else if (x1[i] + deltaX1[i] < x2[j] + deltaX2[j]) {
00369       if ( xDiff.empty()) {
00370         xDiff.push_back(x1[i]);
00371         yDiff.push_back(y2[j] - y1[i]);
00372         deltaXDiff.push_back(deltaX1[i]);
00373         i++; 
00374         continue;
00375       } else {
00376         double tmpX = xDiff.back();
00377         double tmpDeltaX = deltaXDiff.back();
00378         double xLeft = tmpX + tmpDeltaX;
00379         double xRight = x1[i] + deltaX1[i];
00380         xDiff.push_back(xLeft+0.5*(xRight - xLeft));
00381         yDiff.push_back(y2[j] - y1[i]);
00382         deltaXDiff.push_back(0.5*(xRight - xLeft));
00383         i++; 
00384         continue;
00385       }  
00386     } else {
00387       if ( xDiff.empty() ) {
00388         xDiff.push_back(x2[j]);
00389         yDiff.push_back(y2[j] - y1[i]);
00390         deltaXDiff.push_back(deltaX2[j]);
00391         j++;
00392         continue;
00393       } else {
00394         double tmpX = xDiff.back();
00395         double tmpDeltaX = deltaXDiff.back();
00396         double xLeft = tmpX + tmpDeltaX;
00397         double xRight = x2[j] + deltaX2[j];
00398         xDiff.push_back(xLeft+0.5*(xRight - xLeft));
00399         yDiff.push_back(y2[j] - y1[i]);
00400         deltaXDiff.push_back(0.5*(xRight - xLeft));
00401         j++;
00402         continue;
00403       }
00404     }
00405   }
00406 
00407   NTuple *  newNtuple = new NTuple();
00408   newNtuple->addColumn ( "X", xDiff );
00409   newNtuple->addColumn ( "Residuals", yDiff );
00410   newNtuple->addColumn ( "DeltaX", deltaXDiff );
00411 
00412   return newNtuple;
00413 }
00414 
00415 PlotterBase *
00416 DisplayController::
00417 createDifferenceDisplay ( PlotterBase * plotter )
00418 {
00419   NTuple * ntuple = createNTupleDiff ( plotter );
00420   int size = ntuple->rows();
00421 
00422   ntuple -> setTitle ( plotter -> getTitle () );
00423 
00424   DataSourceController::instance () -> registerNTuple ( ntuple );
00425 
00426   vector < string > bindings ( 3 );
00427 
00428   bindings[0] = ntuple -> getLabelAt ( 0 );
00429   bindings[1] = ntuple -> getLabelAt ( 1 );
00430   bindings[2] = ntuple -> getLabelAt ( 2 );
00431 
00432   DisplayController * controller = DisplayController::instance ();
00433 
00434 // Make scaling of x-axis match that of the original plot.
00435   PlotterBase * new_plotter = controller -> createDisplay ( "XY Plot",
00436                                                             *ntuple,
00437                                                             bindings );
00438   controller->setLog( new_plotter, "x",
00439                       controller -> getLog( plotter, "x" ) );
00440 
00441   return new_plotter;
00442 }
00443 
00444 
00445 PlotterBase * DisplayController::createPlotter ( const DataRep * rep ) const
00446 {
00447   PlotterFactory * factory = PlotterFactory::instance ();
00448   PlotterBase * plotter = 0;
00449   try {
00450     plotter = factory -> create ( "XyPlotter" );
00451     if ( rep -> hasAxis ( Axes::Z ) ) {
00452       plotter -> setEnableZ ( true );
00453     }
00454   }
00455   catch ( const FactoryException & ) {
00456     assert ( false );
00457   }
00458 return plotter;
00459 }
00460 
00463 DataRep *
00464 DisplayController::
00465 addDataRep ( PlotterBase * plotter,
00466              const std::string & type,
00467              const DataSource * tuple,
00468              const std::vector < std::string > & bindings ) const
00469 {
00470   bool yes = isCompatible ( plotter, type );
00471   if ( ! yes ) return 0;
00472 
00473   DataRepController * controller = DataRepController::instance ();
00474   DataRep * rep = controller->createDataRep ( type, tuple, bindings );
00475   addDataRep ( plotter, rep );
00476 
00477   return rep;
00478 }
00479 
00480 void
00481 DisplayController::
00482 stackDataRep ( PlotterBase * plotter, DataRep * rep ) const
00483 {
00484   XyPlotter * xyplotter = dynamic_cast < XyPlotter * > ( plotter );
00485   xyplotter -> addDataRepStacked ( rep );
00486 }
00487 
00488 DataRep *
00489 DisplayController::
00490 addDataRepStacked ( PlotterBase * plotter,
00491                     const std::string & type,
00492                     const DataSource * tuple,
00493                     const std::vector < std::string > & bindings ) const
00494 {
00495   bool yes = isCompatible ( plotter, type );
00496   if ( ! yes ) return 0;
00497 
00498   DataRepController * controller = DataRepController::instance ();
00499   DataRep * rep = controller->createDataRep ( type, tuple, bindings );
00500 
00501   stackDataRep ( plotter, rep );
00502 
00503   return rep;
00504 }
00505 
00506 LineDataRep *
00507 DisplayController::
00508 addLineRep ( PlotterBase * plotter, hippodraw::Axes::Type axis, double value )
00509 {
00510   LineDataRep * rep = new LineDataRep ( axis, value );
00511   addDataRep ( plotter, rep );
00512 
00513   return rep;
00514 }
00515 
00516 LineDataRep *
00517 DisplayController::
00518 addLineRep ( PlotterBase * plotter, const std::string & axis, double value )
00519 {
00520   Axes::Type type = Axes::convert ( axis );
00521 
00522   return addLineRep ( plotter, type, value );
00523 }
00524 
00525 void
00526 DisplayController::
00527 fixLogIfBinned ( const PlotterBase * plotter, DataRep * rep ) const
00528 {
00529   setBinner ( plotter, rep, Axes::X );
00530   setBinner ( plotter, rep, Axes::Y );
00531 }
00532 
00536 void
00537 DisplayController::
00538 addDataRep ( PlotterBase * plotter,  DataRep * rep ) const
00539 {
00540   if ( plotter -> getNumDataReps () > 0 ) {
00541      fixLogIfBinned ( plotter, rep );
00542   }
00543 
00544   plotter->addDataRep ( rep );
00545 
00546   if ( !rep->hasZeroRows() ){
00547        plotter->checkAxisScaling ( );
00548   }
00549 
00550 }
00551 
00554 bool 
00555 DisplayController::
00556 isCompatible ( const PlotterBase * plotter,
00557                const std::string & datarep ) const
00558 {
00559   DataRepFactory * factory = DataRepFactory::instance ();
00560   DataRep * proto = factory->prototype ( datarep );
00561 
00562   bool yes = true;
00563   // does it need Z axis display
00564   if ( proto -> hasAxis ( Axes::Z ) ) {
00565     yes = plotter->hasAxis ( Axes::Z );
00566   }
00567 
00568   return yes;
00569 }
00570 
00571 void
00572 DisplayController::
00573 removeTextObservers ( const std::vector < const ViewBase * > & views )
00574 {
00575 #ifdef ITERATOR_MEMBER_DEFECT
00576   std:: 
00577 #endif
00578   vector < const ViewBase * > ::const_iterator iter = views.begin();
00579   
00580   while ( iter != views.end() ) {
00581 
00582     // If its a text view, tell the target DataRep (observable) to remove
00583     // this->plotter from its list of observers.
00584 
00585     const ViewBase * curview = ( * iter++ );
00586     PlotterBase * curplotter = curview->getPlotter ();
00587 
00588     TextPlotter * textPlotter 
00589       = dynamic_cast < TextPlotter * > ( curplotter );
00590 
00591     if ( textPlotter ){
00592       const DataRep * target = textPlotter->getParentDataRep();
00593       if ( target ){
00594         DataRep * tar = const_cast < DataRep * > ( target );
00595         tar->removeObserver ( textPlotter );
00596       }
00597     }
00598   }
00599 }
00600 
00601 void
00602 DisplayController::
00603 addTextViewToList ( std::vector < const ViewBase * > & dest,
00604                     const std::vector < const ViewBase * > & src )
00605 {
00606   std::vector < const ViewBase * > ::const_iterator first = src.begin();
00607   while ( first != src.end() ) {
00608     const ViewBase * view = *first++;
00609 
00610     vector < const ViewBase * > :: iterator i 
00611       = find ( dest.begin(), dest.end (), view );
00612     if ( i != dest.end() ) continue; // already in list
00613 
00614     PlotterBase * plotter = view->getPlotter ();
00615     TextPlotter * text_plotter = dynamic_cast < TextPlotter * > ( plotter );
00616     if ( text_plotter == 0 ) continue; // not a text plotter
00617 
00618     const DataRep * datarep = text_plotter->getParentDataRep ();
00619     bool add_to_list = false;
00620     for ( i = dest.begin (); i !=  dest.end(); ++i ) {
00621       const ViewBase * view = *i;
00622       PlotterBase * plotter = view->getPlotter ();
00623       if ( plotter == 0 ) continue; // view has no plotter, can be groupview
00624       int num = plotter->getNumDataReps ();
00625       for ( int j = 0; j < num; j++ ) {
00626         DataRep * rep = plotter->getDataRep ( j );
00627         if ( rep == datarep ) { 
00628           add_to_list = true;
00629           break;
00630         }
00631       }
00632       if ( add_to_list ) break;
00633     }
00634     if ( add_to_list ) dest.push_back ( view );
00635   }
00636 }
00637 
00638 bool 
00639 DisplayController::
00640 isAxisBinned (  PlotterBase * plotter,
00641                 const std::string & axis )
00642 {
00643   bool yes = false;
00644 
00645   int index = plotter->activePlotIndex ( );
00646   if ( index < 0 ) {
00647     FunctionController * controller = FunctionController::instance();
00648     index = controller->getUniqueNonFunctionIndex ( plotter );
00649   }
00650   if ( index >=  0 ) {
00651     ProjectorBase * projector = plotter->activeProjector ();
00652     yes = projector->isAxisBinned ( axis );
00653   }
00654 
00655   return yes;
00656 }
00657 
00658 ViewBase * DisplayController::createTextView ( const ViewFactory * v_factory,
00659                                                PlotterBase * plotter,
00660                                                const std::string & name,
00661                                                const std::string & text)
00662 {
00663   int index = activeDataRepIndex ( plotter );
00664   DataRep * datarep = plotter->getDataRep ( index );
00665   ViewBase * view = createTextView ( v_factory, datarep, name, text );
00666   assert ( view != 0 );
00667 
00668   // Set the parent plotter of the text plotter.
00669   view->getPlotter()->setParentPlotter(plotter);
00670 
00671   return view;
00672 }
00673 
00674 const vector < string > & 
00675 DisplayController::
00676 getTextTypes () const
00677 {
00678   TextRepFactory * text_factory = TextRepFactory::instance ();
00679 
00680   return text_factory->names ();
00681 }
00682 
00683 DataRep * DisplayController::createTextDataRep ( const std::string & name,
00684                                                  const std::string & text)
00685 {
00686   TextRepFactory * text_factory = TextRepFactory::instance ();
00687   RepBase * textrep = text_factory->create ( name );
00688   assert ( textrep != 0 );
00689 
00690   textrep->setText ( text );
00691   DataRep * datarep = new TextDataRep ( textrep );
00692 
00693   return datarep;
00694 }
00695 
00696 PlotterBase * 
00697 DisplayController::createTextPlotter ( DataRep * datarep, 
00698                                        const std::string & name,
00699                                        const std::string & text)
00700 {
00701   DataRep * textdatarep = createTextDataRep ( name, text );
00702   TextPlotter * plotter = new TextPlotter ( );
00703   plotter->addDataRep ( textdatarep );
00704   plotter->setParentDataRep ( datarep );
00705 
00706   return plotter;
00707 }
00708 
00709 ViewBase * DisplayController::createTextView ( const ViewFactory * v_factory,
00710                                                DataRep * datarep,
00711                                                const std::string & name,
00712                                                const std::string & text)
00713 {
00714   PlotterBase * plotter = createTextPlotter ( datarep, name, text );
00715 
00716   return v_factory->createView ( plotter );
00717 }
00718 
00719 int DisplayController::
00720 activeDataRepIndex ( const PlotterBase * plotter ) const
00721 {
00722   int index = plotter->activePlotIndex ();
00723   if ( index < 0 ) {
00724     FunctionController * controller = FunctionController::instance ();
00725     index = controller->getUniqueNonFunctionIndex ( plotter );
00726   }
00727   return index;
00728 }
00729 
00730 DataRep *
00731 DisplayController::
00732 activeDataRep ( const PlotterBase * plotter ) const
00733 {
00734   DataRep * rep = 0;
00735   int index = activeDataRepIndex ( plotter );
00736   if ( index >= 0 ) {
00737     rep = plotter -> getDataRep ( index );
00738   }
00739 
00740   return rep;
00741 }
00742 
00743 void
00744 DisplayController::
00745 setActiveDataRepIndex ( PlotterBase * plotter, int index )
00746 {
00747   plotter -> setActivePlot ( index, true );
00748 }
00749 
00750 const vector < string > & 
00751 DisplayController::
00752 axisBindings ( const PlotterBase * plotter ) const
00753 {
00754   //  This only make sense for a NTupleProjector, so we downcast
00755   NTupleProjector * ntProjector =
00756     dynamic_cast <NTupleProjector *> ( plotter->activeProjector() );
00757 
00758   if ( ntProjector == 0 ) return m_null_vector;
00759 
00760   return ntProjector->getAxisBindings ();
00761 }
00762 
00763 const vector < string > &
00764 DisplayController::bindingOptions ( const PlotterBase * plotter,
00765                                     int index )
00766 {
00767   DataRep * rep = plotter->getDataRep ( index );
00768   DataRepController * controller = DataRepController::instance ();
00769 
00770   return controller->bindingOptions ( rep );
00771 }
00772 
00773 const vector < string > &
00774 DisplayController::
00775 bindingOptions ( const std::string & type )
00776 {
00777   DataRepFactory * factory = DataRepFactory::instance ();
00778   DataRep * rep = factory -> prototype ( type );
00779   DataRepController * controller = DataRepController::instance ();
00780   
00781   return controller -> bindingOptions ( rep );
00782 }
00783 
00784 const vector < string > & 
00785 DisplayController::
00786 axisBindings ( const PlotterBase * plotter, int index ) const
00787 {
00788   assert ( index < plotter->getNumDataReps () );
00789 
00790   ProjectorBase * pbase = plotter->getProjector ( index );
00791   //  This only make sense for a NTupleProjector, so we downcast
00792   NTupleProjector * ntProjector =
00793     dynamic_cast <NTupleProjector *> ( pbase );
00794 
00795   if ( ntProjector == 0 ) return m_null_vector;
00796 
00797   return ntProjector->getAxisBindings ();
00798 }
00799 
00800 int
00801 DisplayController::
00802 getNumberOfEntries ( const PlotterBase * plotter, int index ) const
00803 {
00804   assert ( index < plotter->getNumDataReps () );
00805 
00806   ProjectorBase * projector = plotter -> getProjector ( index );
00807 
00808   return projector -> getNumberOfEntries ();
00809 }
00810 
00811 int
00812 DisplayController::
00813 getUnderflow ( const PlotterBase * plotter, int index ) const
00814 {
00815   assert ( index < plotter->getNumDataReps () );
00816   ProjectorBase * projector = plotter -> getProjector ( index );
00817   return projector -> getUnderflow ();
00818 }
00819 
00820 int
00821 DisplayController::
00822 getOverflow ( const PlotterBase * plotter, int index ) const
00823 {
00824   assert ( index < plotter->getNumDataReps () );
00825   ProjectorBase * projector = plotter -> getProjector ( index );
00826   return projector -> getOverflow ();
00827 }
00828 
00829 double
00830 DisplayController::
00831 getAverage ( const PlotterBase * plotter, 
00832              const std::string & axis, int index ) const
00833 {
00834   Axes::Type a = Axes::convert ( axis );
00835 
00836   return getAverage ( plotter, a, index );
00837 }
00838 
00839 double
00840 DisplayController::
00841 getAverage ( const PlotterBase * plotter,
00842              hippodraw::Axes::Type axis,
00843              int index ) const
00844 {
00845   assert ( index < plotter -> getNumDataReps () );
00846 
00847   ProjectorBase * projector = plotter -> getProjector ( index );
00848 
00849   return projector -> getAverage ( axis );
00850 }
00851 
00852 double
00853 DisplayController::
00854 getRMS ( const PlotterBase * plotter, 
00855          const std::string & axis, int index ) const
00856 {
00857   Axes::Type a = Axes::convert ( axis );
00858 
00859   return getRMS ( plotter, a, index );
00860 }
00861 
00862 double
00863 DisplayController::
00864 getRMS ( const PlotterBase * plotter,
00865          hippodraw::Axes::Type axis,
00866          int index ) const
00867 {
00868   assert ( index < plotter -> getNumDataReps () );
00869 
00870   ProjectorBase * projector = plotter -> getProjector ( index );
00871 
00872   return projector -> getRMS ( axis );
00873 }
00874 
00875 const string & DisplayController::getType ( const PlotterBase * plotter,
00876                                             int index ) const
00877 {
00878   DataRep * datarep = plotter->getDataRep ( index );
00879 
00880   return datarep->name ();
00881 }
00882 
00883 ProjectorBase * 
00884 DisplayController::getProjector ( const PlotterBase * plotter ) const
00885 {
00886   DataRep * datarep = plotter->selectedDataRep ();
00887 
00888   if ( datarep == 0 ) return 0;
00889 
00890   return datarep->getProjector ();
00891 }
00892 
00896 NTupleProjector * 
00897 DisplayController::getBindingProjector ( const PlotterBase * plotter ) const
00898 {
00899   ProjectorBase * projbase = getProjector ( plotter );
00900   if ( projbase != 0 ) {
00901     NTupleProjector * projector 
00902       = dynamic_cast < NTupleProjector * > ( projbase );
00903     return projector;
00904   }
00905   // Failure of the above is because multiple DataRep objects are
00906   // selected.  However, if the the additional ones are all
00907   // FunctionRep objects, then we want to find the single DataRep
00908   // object.
00909   int number = plotter->getNumDataReps ();
00910   for ( int i = 0; i < number; i++ ) {
00911     DataRep * rep = plotter->getDataRep ( i );
00912     FunctionRep * frep = dynamic_cast < FunctionRep * > ( rep );
00913     if ( frep != 0 ) continue;
00914     if ( projbase == 0 ) { 
00915       projbase = rep->getProjector ();
00916     }
00917     else {
00918       return 0; // multiple non- FunctionRep objects found
00919     }
00920   }
00921   NTupleProjector * projector 
00922     = dynamic_cast < NTupleProjector * > ( projbase );
00923 
00924   return projector;
00925 }
00926 
00927 void DisplayController::setNTuple ( PlotterBase * plotter,
00928                                     const NTuple * ntuple ) const
00929 {
00930   NTupleProjector * projector = getBindingProjector ( plotter );
00931   if ( projector == 0 ) return;
00932 
00933   projector->setNTuple ( ntuple );
00934   NTuple * nt = const_cast < NTuple * > ( ntuple );
00935   nt->addObserver ( projector );
00936   DataRep * datarep = plotter->selectedDataRep ();
00937 
00938   datarep->notifyObservers ();
00939 }
00940 DataSource *
00941 DisplayController::
00942 getDataSource ( const PlotterBase * plotter )
00943 {
00944   DataSource * source = 0;
00945   int index = activeDataRepIndex ( plotter );
00946   int numDataReps = plotter -> getNumDataReps ();
00947   if ( index >= 0 || numDataReps < 2 ) {
00948     source = getDataSource ( plotter, 0 );
00949   }
00950   else {
00951     source = getDataSource ( plotter, 0 );
00952     for ( int i = 1; i< numDataReps; i++ ) {
00953       const DataSource * nt = getDataSource ( plotter, i );
00954       if ( source != nt ) {
00955         source = 0;
00956         break;
00957       }
00958     }
00959   }
00960   return source;
00961 }
00962 
00963 DataSource * 
00964 DisplayController::
00965 getDataSource ( const PlotterBase * plotter, int index )
00966 {
00967   DataSource * source = 0;
00968 
00969   DataRep * rep = plotter->getDataRep ( index );
00970   if ( rep->hasNTupleBindings () ) {
00971     ProjectorBase * pbase = rep->getProjector ();
00972     NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00973     if ( projector != 0 ) {
00974       source = projector -> getNTuple ();
00975     }
00976   }
00977 
00978   return source;
00979 }
00980 
00981 void
00982 DisplayController::
00983 setIntervalCount ( const PlotterBase * plotter, unsigned int count )
00984 {
00985   int i = activeDataRepIndex ( plotter );
00986   if ( i < 0 ) return;
00987   DataSource * ds = getDataSource ( plotter, i );
00988   NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
00989 
00990   if ( ntuple != 0 ) ntuple->setIntervalCount ( count );
00991 }
00992 
00993 void
00994 DisplayController::
00995 setIntervalEnabled ( const PlotterBase * plotter, bool yes )
00996 {
00997   int i = activeDataRepIndex ( plotter );
00998   if ( i < 0 ) return;
00999   DataSource * ds = getDataSource ( plotter, i );
01000   NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
01001 
01002   if ( ntuple != 0 ) ntuple->setIntervalEnabled ( yes );
01003 }
01004 
01005 void
01006 DisplayController::
01007 setAllIntervalEnabled ( const PlotterBase * plotter, bool yes )
01008 {
01009   int number = plotter->getNumDataReps ();
01010   for ( int i = 0; i < number; i++ ) {
01011     DataSource * ds = getDataSource ( plotter, i );
01012     NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
01013     if ( ntuple != 0 ) ntuple->setIntervalEnabled ( yes );
01014   }
01015 }
01016 
01017 bool
01018 DisplayController::
01019 areDataSourcesSaved ( const PlotterBase * plotter )
01020 {
01021   bool yes = true;
01022   DataSourceController * controller = DataSourceController::instance ();
01023 
01024   int number = plotter->getNumDataReps ();
01025   for ( int i = 0; i < number; i++ ) {
01026     const DataSource * source = getDataSource ( plotter, i );
01027     if ( source != 0 ) {
01028       yes = controller -> isFromFile ( source );
01029     }
01030     if ( yes == false ) break;
01031   }
01032 
01033   return yes;
01034 }
01035 
01036 bool DisplayController::hasNTupleBindings ( const PlotterBase * plotter,
01037                                             int index )
01038 {
01039   assert ( ! ( index < 0 ) );
01040   DataRep * rep = plotter->getDataRep ( index );
01041 
01042   return rep->hasNTupleBindings ();
01043 }
01044 
01045 const string & 
01046 DisplayController::
01047 getDataSourceName ( const PlotterBase * plotter,
01048                     int index )
01049 {
01050   const DataSource * source = getDataSource ( plotter, index );
01051 
01052   return source -> getName ();
01053 }
01054 
01055 const vector < string > & 
01056 DisplayController::getDataSourceLabels ( const PlotterBase * plotter,
01057                                          int index )
01058 {
01059   DataRep * datarep = plotter->getDataRep ( index );
01060   ProjectorBase * pbase = datarep->getProjector ();
01061   NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
01062   if ( projector == 0 ) return m_null_vector;
01063 
01064   const DataSource * tuple = projector->getNTuple ();
01065 
01066   return tuple->getLabels ();
01067 }
01068 
01069 DataRep *
01070 DisplayController::
01071 getUniqueWithNTupleBindings ( const PlotterBase * plotter )
01072 {
01073   DataRep * rep = 0;
01074   int active = plotter -> activePlotIndex ();
01075 
01076   if ( active < 0 ) { // multiple active
01077     int count = 0;
01078     int number = plotter -> getNumDataReps ();
01079     for ( int i = 0; i < number; i++ ) {
01080       DataRep * trep = plotter -> getDataRep ( i );
01081       if ( trep -> hasNTupleBindings () ) {
01082         if ( count == 0 ) {
01083           rep = trep;
01084           count ++;
01085         }
01086         else {
01087           rep = 0;
01088           break;
01089         }
01090       }
01091     }
01092   } 
01093   else { // only one active
01094     rep = plotter ->getDataRep ( active );
01095     if ( rep ->hasNTupleBindings () == false ) {
01096       rep = 0;
01097     }
01098   }
01099 
01100   return rep;
01101 }
01102 
01103 void  DisplayController::setAxisBinding ( PlotterBase * plotter,
01104                                           const std::string & axis,
01105                                           const std::string & label )
01106 {
01107   DataRep * rep = plotter -> getTarget ();
01108 
01109   if ( rep != 0 ) {
01110     rep -> setAxisBinding ( axis, label );
01111     Axes::Type a = Axes::X;
01112     if ( axis[0] == 'Y' ) a = Axes::Y;
01113     plotter -> setAutoRanging ( a, true );
01114     plotter -> autoScale ();
01115   }
01116 }
01117 
01118 void DisplayController::
01119 setAxisBindings ( PlotterBase * plotter,
01120                   const std::vector< std::string > & labels ) const
01121 {
01122   NTupleProjector * projector = getBindingProjector ( plotter );
01123   if ( projector == 0 ) return;
01124 
01125   projector->setAxisBindings ( labels );
01126   plotter->setAutoRanging ( true );
01127 
01128 }
01129 
01130 bool
01131 DisplayController::
01132 isDataValid ( const PlotterBase * plotter ) const
01133 {
01134   bool valid = true;
01135   const DataRep * rep = plotter -> getTarget ();
01136   if ( rep != 0 ) {
01137     valid = isDataValid ( rep );
01138   }
01139 
01140   return valid;
01141 }
01142 
01143 bool
01144 DisplayController::
01145 isDataValid ( const DataRep * rep ) const
01146 {
01147   bool valid = true;
01148   ProjectorBase * base = rep -> getProjector ();
01149   const NTupleProjector * projector 
01150     = dynamic_cast < const NTupleProjector * > ( base );
01151   if ( projector != 0 ) {
01152     valid = projector -> isDataValid ();
01153   }
01154 
01155   return valid;
01156 }
01157 
01158 bool
01159 DisplayController::
01160 getLog ( const PlotterBase * plotter, 
01161          const std::string & axis) const
01162 {
01163    Axes::Type at = Axes::convert ( axis );
01164    return getLog ( plotter, at );
01165 }
01166 
01168 bool
01169 DisplayController::
01170 getLog ( const PlotterBase * plotter, hippodraw::Axes::Type axis ) const
01171 {
01172   assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
01173 
01174   XYTransform * xy_transform 
01175     = dynamic_cast < XYTransform *> ( plotter->getTransform () );
01176 
01177   if ( xy_transform == 0 ) return false;
01178 
01179   TransformBase * transform = 0;
01180  
01181  if ( axis == Axes::X ){
01182     transform = xy_transform->xTransform ();
01183   }
01184   if ( axis == Axes::Y ){
01185     transform = xy_transform->yTransform();
01186   }
01187   if ( axis == Axes::Z ){
01188     transform = xy_transform->zTransform();
01189   }
01190 
01191   assert ( transform );
01192   
01193   const string & name = transform->name ();
01194 
01195   return name == "Log";
01196 }
01197 void
01198 DisplayController::
01199 setBinner ( const PlotterBase * plotter,
01200             DataRep * datarep, 
01201             hippodraw::Axes::Type axis ) const
01202 {
01203   ProjectorBase * projbase = datarep->getProjector ();
01204 
01205   BinningProjector * projector
01206     = dynamic_cast< BinningProjector * > ( projbase );
01207   if ( projector == 0 ) return;
01208 
01209   if ( axis == Axes::Y &&
01210        projector->isAxisBinned ( "Y" ) == false ) return;
01211 
01212   const Range & range = plotter -> getRange ( axis, false );
01213   BinnerAxis * binner = 0;
01214 
01215   BinnerAxisFactory * binner_factory = BinnerAxisFactory::instance ();
01216   AxisModelBase * model = plotter -> getAxisModel ( axis );
01217 
01218   if ( model->isLog() ) {
01219     binner = binner_factory -> create ( "BinnerLog" );
01220   } else { // not Log
01221     binner = binner_factory -> create ( "BinnerLinear" );
01222   }
01223 
01224   binner->setRange ( range, false );
01225   projector->setBinnerOn ( binner, axis );
01226 }
01227 
01231 void
01232 DisplayController::
01233 setBinner ( PlotterBase * plotter, 
01234             hippodraw::Axes::Type axis )
01235 {
01236   int number = plotter->getNumDataReps ();
01237   for ( int i = 0; i < number; i++ ) {
01238     DataRep * datarep = plotter->getDataRep ( i );
01239     setBinner ( plotter, datarep, axis );
01240   }
01241 
01242 }
01243 
01244 void
01245 DisplayController::
01246 setAxisModel ( PlotterBase * plotter, 
01247                hippodraw::Axes::Type axis,
01248                const std::string & type )
01249 {
01250   AxisModelBase * model = plotter->getAxisModel ( axis );
01251 
01252   if ( model != 0 ) {
01253     AxisModelBase * temp = 0;
01254   
01255     if ( type == "Linear" ) {
01256     
01257       if ( !( model->isLog() ) ) return; // no change needed
01258       temp = new AxisModelLinear ( *model );
01259   
01260     } 
01261     else if ( type == "Log" ) {
01262   
01263       if ( model->isLog () ) return; // no change needed
01264       const Range & range = plotter -> getRange ( axis, false );
01265       if ( range.high() < 0. ) {
01266         string what ( "Can not change axis to log scale since current "
01267                       "range is negative" );
01268         throw std::runtime_error ( what );
01269       }
01270 
01271       double pos = plotter->getPosRange ( axis );
01272       model->setRangePos ( pos );
01273       temp = new AxisModelLog ( *model );
01274   
01275     }
01276   
01277     assert ( temp );
01278 
01279     swap ( temp, model );
01280 
01281     plotter->setAxisModel ( model, axis );
01282 
01283     setBinner ( plotter, axis );
01284 
01285     // Do not delete until the end so project can use it.
01286     delete temp;
01287   }
01288 }
01289 
01290 void
01291 DisplayController::
01292 setLog ( PlotterBase * plotter, 
01293          const std::string & axis, 
01294          bool flag )
01295 {
01296   Axes::Type at = Axes::convert ( axis );
01297   setLog ( plotter, at, flag );
01298 }
01299 
01301 void
01302 DisplayController::
01303 setLog ( PlotterBase * plotter,
01304          hippodraw::Axes::Type axis,
01305          bool flag )
01306 {
01307   assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
01308   
01309   TransformBase * current = plotter->getTransform ();
01310 
01311   XYTransform * xy_transform = dynamic_cast < XYTransform *> ( current );
01312 
01313   if ( xy_transform != 0 ) {
01314     setLog ( plotter, axis, flag, xy_transform );
01315     return;
01316   }
01317   assert ( axis == Axes::Z );
01318   BinaryTransform * b_transform 
01319     = dynamic_cast < BinaryTransform * > ( current );
01320   string type;
01321   if ( flag ) type = "Log";
01322   else type = "Linear";
01323   
01324   setAxisModel ( plotter, Axes::Z , type );
01325 
01326   TransformFactory * factory = TransformFactory::instance ();
01327   TransformBase * transform = factory -> createTransform ( type );
01328 
01329   b_transform -> setZTransform ( transform );
01330   plotter -> setTransform ( b_transform );
01331 }
01332 
01333 void
01334 DisplayController::
01335 setLog ( PlotterBase * plotter,
01336          hippodraw::Axes::Type axis,
01337          bool flag, 
01338          XYTransform * xy_transform )
01339 {
01340   TransformBase * transform = xy_transform->xTransform ();
01341 
01342   string x_trans = transform->name ();
01343   transform = xy_transform->yTransform ();
01344   string y_trans = transform->name ();
01345   transform = xy_transform->zTransform ();
01346   string z_trans = transform->name ();
01347 
01348   if( flag ){ //if the axis is to be made logarithmic
01349     if( axis == Axes::X ){
01350       x_trans = "Log";
01351       setAxisModel ( plotter, Axes::X, x_trans );
01352     }
01353     if( axis == Axes::Y ){
01354       y_trans = "Log";
01355       setAxisModel ( plotter, Axes::Y, y_trans );
01356     }
01357     if( axis == Axes::Z ){
01358       z_trans = "Log";
01359       setAxisModel ( plotter, Axes::Z, z_trans );
01360     }
01361   }
01362   
01363   if( !flag ){
01364     if( axis == Axes::X ) {
01365       x_trans = "Linear";
01366       setAxisModel ( plotter, Axes::X, x_trans );
01367     }
01368     if( axis == Axes::Y ) {
01369       y_trans = "Linear";
01370       setAxisModel ( plotter, Axes::Y , y_trans );
01371     }
01372     if( axis == Axes::Z ) {
01373       z_trans = "Linear";
01374       setAxisModel ( plotter, Axes::Z , z_trans );
01375     }
01376   }
01377   
01378   TransformFactory * factory = TransformFactory::instance ();
01379 
01380 // The following verbosness for VC++ in debug mode.
01381   string t_name = x_trans;
01382   t_name += " ";
01383   t_name += y_trans;
01384   t_name += " ";
01385   t_name += z_trans;
01386   transform = factory->createTransform ( t_name );
01387 
01388   plotter->setTransform ( transform );
01389   delete transform; // The plotter made a copy and deleted the old one.
01390 }
01391 
01392 
01393 void DisplayController::setTransform ( PlotterBase * plotter,
01394                                        const std::string & name )
01395 {
01396   TransformFactory * factory = TransformFactory::instance ();
01397   TransformBase * transform = factory->createTransform ( name );
01398 
01399   try {
01400      plotter->setTransform ( transform );
01401      delete transform; // The plotter made a copy.
01402   } catch (PlotterException & eObj) {
01403      delete transform; // not used or needed
01404      throw eObj;
01405   }
01406 }
01407 
01408 void DisplayController::setTransform ( PlotterBase * plotter,
01409                                        const std::string & x,
01410                                        const std::string & y )
01411 {
01412   TransformFactory * factory = TransformFactory::instance ();
01413   const string name = x + " " + y;
01414   TransformBase * transform = factory->createTransform ( name );
01415 
01416   plotter->setTransform ( transform );
01417 
01418   delete transform; // The plotter made a copy.
01419 }
01420 
01421 void DisplayController:: remove ( PlotterBase * plotter )
01422 {
01423   delete plotter;
01424 }
01425 
01426 float DisplayController::pointSize ( const PlotterBase * plotter ) const
01427 {
01428   RepBase * rep = plotter->representation ();
01429   
01430   return rep->size ();
01431 }
01432 
01433 bool
01434 DisplayController::
01435 hasSymbolRep ( const PlotterBase * plotter ) const
01436 {
01437   RepBase * rep = plotter -> representation ();
01438   SymbolPointRep * symrep = dynamic_cast < SymbolPointRep * > ( rep );
01439   
01440   return symrep != 0;
01441 }
01442 
01443 bool
01444 DisplayController::
01445 hasLineRep ( const PlotterBase * plotter ) const
01446 {
01447   bool yes = false;
01448 
01449   RepBase * rep = plotter -> representation ();
01450   ColumnPointRep * colrep = dynamic_cast < ColumnPointRep * > ( rep );
01451   
01452   if ( colrep != 0 ) {
01453     yes = true;
01454   }
01455   else {
01456     LinePointRep * linerep = dynamic_cast < LinePointRep * > ( rep );
01457     yes = linerep != 0;
01458   }
01459 
01460   return yes;
01461 }
01462 
01463 unsigned int
01464 DisplayController::
01465 getRepStyle ( const PlotterBase * plotter ) const
01466 {
01467   RepBase * rep = plotter -> representation ();
01468 
01469   return rep -> getStyle ();
01470 }
01471 
01472 void DisplayController::setRepSize ( PlotterBase * plotter, float size )
01473 {
01474   DataRep * datarep = plotter->selectedDataRep ();
01475 
01476   datarep->setRepSize ( size );
01477 }
01478 
01479 void
01480 DisplayController::
01481 setPointRep ( PlotterBase * plotter, const std::string & point_rep )
01482 {
01483   int index = activeDataRepIndex ( plotter );
01484   if ( index >= 0 ) {
01485     DataRep * datarep = plotter -> getDataRep ( index );
01486     assert ( datarep );
01487     PointRepFactory * factory = PointRepFactory::instance ();
01488     RepBase * rep = factory -> create (  point_rep );
01489     datarep -> setPointRep ( rep );
01490   }
01491 }
01492 
01493 void
01494 DisplayController::
01495 setRange ( PlotterBase * plotter,
01496            hippodraw::Axes::Type axis, 
01497            const Range & range )
01498 {
01499   plotter->setRange ( axis, range );
01500 
01501   plotter->setAutoRanging ( axis, false );
01502 }
01503 
01504 void 
01505 DisplayController::
01506 setBinWidth ( PlotterBase * plotter,
01507               const std::string & axis,
01508               double width )
01509 {
01510   Axes::Type at = Axes::convert ( axis );
01511 
01512   setBinWidth ( plotter, at, width );
01513 }
01514 
01515 void
01516 DisplayController::
01517 setBinWidth ( DataRep * datarep,
01518               hippodraw::Axes::Type axis,
01519               double width )
01520 {
01521   const list < Observer * > & obs_list = datarep -> getObservers ();
01522   list < Observer * >::const_iterator first = obs_list.begin();
01523   while ( first != obs_list.end () ) {
01524     Observer * obs = *first++;
01525     PlotterBase * plotter = dynamic_cast < PlotterBase * > ( obs );
01526     if ( plotter != 0 ) {
01527       plotter -> autoScale ();
01528       datarep -> setBinWidth ( axis, width );
01529       plotter -> setAutoRanging ( axis, false );
01530       break;
01531     }
01532   }
01533 }
01534 
01535 void
01536 DisplayController::
01537 setBinWidth ( PlotterBase * plotter,
01538               hippodraw::Axes::Type axis,
01539               double width )
01540 {
01541   plotter -> setBinWidth ( axis, width );
01542   plotter->setAutoRanging ( axis, false );
01543 }
01544 
01549 void
01550 DisplayController::
01551 setOffset ( PlotterBase * plotter,
01552             const std::string & axis,
01553             int parm,
01554             bool dragging )
01555 {
01556   bool widths_are_same = false;
01557 
01558   Axes::Type at = Axes::X;
01559   if ( axis == "Y" ) at = Axes::Y;
01560   if ( axis == "Z" ) at = Axes::Z;
01561   plotter->setAutoRanging ( at, false );
01562 
01563   int index = plotter->activePlotIndex ();
01564 
01565   if ( index < 0 ) {
01566     int number = plotter->getNumDataReps ();
01567     for ( int i = 0; i < number; i++ ) {
01568       ProjectorBase * projector = plotter->getProjector ( i );
01569       projector->setOffset ( axis, parm, dragging );
01570     }
01571 
01572     widths_are_same = true;
01573   }
01574   else {
01575     ProjectorBase * projector = plotter->getProjector ( index );
01576     projector->setOffset ( axis, parm, dragging );
01577   }
01578 
01579 }
01580 
01581 void
01582 DisplayController::
01583 setOffset ( PlotterBase * plotter,
01584             hippodraw::Axes::Type axis,
01585             double offset )
01586 {
01587   bool widths_are_same = false;
01588   
01589   int index = plotter->activePlotIndex ();
01590   
01591   if ( index < 0 ) {
01592     int number = plotter->getNumDataReps ();
01593     for ( int i = 0; i < number; i++ ) {
01594       ProjectorBase * projector = plotter->getProjector ( i );
01595       projector->setOffset ( axis, offset );
01596     }
01597 
01598     widths_are_same = true;
01599   }
01600   else {
01601     ProjectorBase * projector = plotter->getProjector ( index );
01602     projector->setOffset ( axis, offset );
01603   }
01604 
01605 }
01606 
01607 void
01608 DisplayController::
01609 setErrorDisplayed ( const PlotterBase * plotter, 
01610                     hippodraw::Axes::Type axis,
01611                     bool state ) const
01612 {
01613   int index = activeDataRepIndex ( plotter );
01614   if ( index >= 0 ) {
01615     DataRep * rep = plotter -> getDataRep ( index );
01616     rep -> setErrorDisplay ( axis, state );
01617   }
01618 }
01619 
01620 void
01621 DisplayController::
01622 createNTuple ( const PlotterBase * plotter )
01623 {
01624   int index = plotter -> activePlotIndex ();
01625 //   if ( index < 0 ) return;
01626 
01627   NTuple * ntuple = plotter -> createNTuple ();
01628   DataSourceController::instance () -> registerNTuple ( ntuple );
01629 }
01630 
01631 void
01632 DisplayController::
01633 setTransformAxis ( PlotterBase * plotter, 
01634                    const std::string & x, 
01635                    const std::string & y)
01636 {
01637   setAxisModelWithoutSetBin ( plotter, Axes::X, x );
01638   setAxisModelWithoutSetBin ( plotter, Axes::Y, y );
01639 }
01640 
01641 
01642 void
01643 DisplayController::
01644 setAxisModelWithoutSetBin ( PlotterBase * plotter, 
01645                             hippodraw::Axes::Type axis,
01646                             const std::string & type )
01647 {
01648   AxisModelBase * model = plotter->getAxisModel ( axis );
01649 
01650   if ( model != 0 ) {
01651     AxisModelBase * temp = 0;
01652   
01653     if ( type == "Linear" ) {
01654     
01655       if ( !( model->isLog() ) ) return; // no change needed
01656       temp = new AxisModelLinear ( *model );
01657   
01658     } 
01659     else if ( type == "Log" ) {
01660   
01661       if ( model->isLog () ) return; // no change needed    
01662       const Range & range = plotter -> getRange ( axis, false );
01663       if ( range.high () < 0. ) {
01664         string what ( "Can not change axis to Log scale since current "
01665                       "range is negative." );
01666         throw std::runtime_error ( what );
01667       }
01668       double pos = plotter->getPosRange ( axis );
01669       model->setRangePos ( pos );
01670       temp = new AxisModelLog ( *model );
01671   
01672     }
01673   
01674     assert ( temp );
01675 
01676     swap ( temp, model );
01677 
01678     plotter->setAxisModel ( model, axis );
01679 
01680     // Do not delete until the end so project can use it.
01681     delete temp;
01682   }
01683 }

Generated for HippoDraw Class Library by doxygen