00001
00012 #ifdef HAVE_CONFIG_H
00013 #include "config.h"
00014 #else
00015
00016
00017 #ifdef _MSC_VER
00018 #include "msdevstudio/MSconfig.h"
00019 #endif
00020
00021 #endif // HAVE_CONFIG_H
00022
00023 #include "DisplayController.h"
00024
00025 #include "DataRepController.h"
00026 #include "FunctionController.h"
00027
00028 #include "axes/AxisModelLog.h"
00029 #include "axes/AxisModelLinear.h"
00030
00031 #include "binners/BinnerAxis.h"
00032 #include "binners/BinnerAxisFactory.h"
00033
00034 #include "datareps/DataRepException.h"
00035 #include "datareps/DataRepFactory.h"
00036 #include "datareps/FunctionRep.h"
00037 #include "datareps/LineDataRep.h"
00038 #include "datareps/TextDataRep.h"
00039 #include "datareps/StripChart.h"
00040
00041 #include "datasrcs/DataSourceController.h"
00042 #include "datasrcs/NTuple.h"
00043 #include "datasrcs/NTupleController.h"
00044
00045 #include "graphics/ViewBase.h"
00046 #include "graphics/ViewFactory.h"
00047
00048 #include "plotters/PlotterException.h"
00049 #include "plotters/PlotterFactory.h"
00050 #include "plotters/TextPlotter.h"
00051 #include "plotters/XyPlotter.h"
00052
00053 #include "projectors/BinningProjector.h"
00054 #include "projectors/NTupleProjector.h"
00055
00056 #include "reps/BinToColor.h"
00057 #include "reps/BinToMovingBrkPt.h"
00058 #include "reps/BinToColorScaleMovingBrkPt.h"
00059 #include "reps/BinToColorFactory.h"
00060 #include "reps/ColumnPointRep.h"
00061 #include "reps/LinePointRep.h"
00062 #include "reps/PointRepFactory.h"
00063 #include "reps/SymbolPointRep.h"
00064 #include "reps/TextRepBase.h"
00065 #include "reps/TextRepFactory.h"
00066
00067 #include "transforms/TransformFactory.h"
00068 #include "transforms/XYTransform.h"
00069
00070 #ifdef HAVE_CFITSIO
00071 #include "fits/FitsController.h"
00072 #endif
00073
00074 #include <algorithm>
00075
00076 #include <cassert>
00077
00078 using namespace hippodraw;
00079
00080 using std::list;
00081 using std::string;
00082 using std::swap;
00083 using std::vector;
00084 using std::find;
00085
00086 DisplayController * DisplayController::s_instance = 0;
00087
00088 DisplayController::DisplayController ( )
00089 {
00090 }
00091
00092 DisplayController::~DisplayController ( )
00093 {
00094 }
00095
00096 DisplayController * DisplayController::instance ( )
00097 {
00098 if ( s_instance == 0 ) {
00099 s_instance = new DisplayController ( );
00100 }
00101 return s_instance;
00102 }
00103
00104 const vector < string > &
00105 DisplayController::
00106 getValueTransformTypes () const
00107 {
00108 BinToColorFactory * factory = BinToColorFactory::instance ();
00109
00110 return factory -> names ();
00111 }
00112
00113 void
00114 DisplayController::
00115 setValueTransform ( PlotterBase * plotter, int index )
00116 {
00117 BinToColorFactory * factory = BinToColorFactory::instance ();
00118 const vector < string > & names = factory -> names ();
00119 BinToColor * rep = factory -> create ( names[index] );
00120 plotter -> setValueRep ( rep );
00121 }
00122
00123 void
00124 DisplayController::
00125 setValueTransform ( PlotterBase * plotter, int index,
00126 const std::vector < std::string > & usr_models,
00127 const std::vector < double > & brk_points,
00128 const std::vector < double > & flat_widths,
00129 const std::vector < double > & color_scales)
00130 {
00131 BinToColorFactory * factory = BinToColorFactory::instance ();
00132 assert(usr_models.size() == brk_points.size());
00133 assert(flat_widths.size() == brk_points.size());
00134 assert(color_scales.size() == brk_points.size());
00135
00136 for ( unsigned int i = 0 ; i < usr_models.size () ; i++ )
00137 factory -> addModel ( usr_models[i] );
00138
00139
00140 const vector < string > & names = factory -> names ();
00141 BinToColor * rep = factory -> create ( names[index] );
00142 int numPreDefinedModels = factory -> get_num_models();
00143
00144 if ( index >= numPreDefinedModels )
00145 {
00146 vector < double > sv;
00147 sv.push_back(brk_points[ index - numPreDefinedModels ]);
00148 sv.push_back(flat_widths[ index - numPreDefinedModels ]);
00149 sv.push_back(color_scales[ index - numPreDefinedModels ]);
00150 rep -> setControlPoints ( sv );
00151 }
00152 plotter -> setValueRep ( rep );
00153 }
00154
00155
00156 const vector <double > &
00157 DisplayController::
00158 getValueBrkPt(PlotterBase *plotter)
00159 {
00160 BinToColor * r = const_cast< BinToColor *> (plotter->getValueRep());
00161
00162 return r -> getControlPoints ();
00163 }
00164
00165 void
00166 DisplayController::
00167 setValueBrkPt ( PlotterBase *plotter,
00168 const std::vector < double > & sv)
00169 {
00170 BinToColor * r = const_cast< BinToColor *> (plotter->getValueRep());
00171
00172 if ( r != 0 ) {
00173 r -> setControlPoints ( sv );
00174 DataRep * datarep = plotter -> selectedDataRep ();
00175 datarep -> notifyObservers ();
00176 }
00177
00178 }
00179
00180
00181
00182 int
00183 DisplayController::
00184 getValueTransformIndex ( PlotterBase * plotter )
00185 {
00186 int index = -1;
00187 const BinToColor * rep = plotter -> getValueRep ();
00188 if ( rep != 0 ) {
00189 const string & name = rep -> name ();
00190 const vector < string > & names = getValueTransformTypes ();
00191 unsigned int size = names.size();
00192 for ( unsigned int i = 0; i < size; i++ ) {
00193 if ( name == names[i] ) {
00194 index = i;
00195 break;
00196 }
00197 }
00198 }
00199
00200 return index;
00201 }
00202
00203 bool
00204 DisplayController::
00205 hasControlPoints ( const PlotterBase * plotter ) const
00206 {
00207 bool yes = false;
00208 const BinToColor * rep = plotter -> getValueRep ();
00209 if ( rep != 0 ) {
00210 yes = rep -> hasControlPoints ();
00211 }
00212
00213 return yes;
00214 }
00215
00216 const vector < string > &
00217 DisplayController::
00218 getDisplayTypes () const
00219 {
00220 DataRepFactory * factory = DataRepFactory::instance ();
00221
00222 return factory -> names ();
00223 }
00224
00225 PlotterBase *
00226 DisplayController::
00227 createDisplay ( const std::string & name )
00228 {
00229 DataRepController * controller = DataRepController::instance ();
00230 DataRep * rep = controller -> createDataRep ( name );
00231 bool yes = rep -> hasNTupleBindings ();
00232
00233 if ( yes ) {
00234 string what ( "DisplayController: data rep of type " );
00235 what += name;
00236 what +="\nhas NTuple bindings.\n";
00237 what += "Can not create without them";
00238 throw DataRepException ( what );
00239 }
00240
00241 PlotterBase * plotter = createPlotter ( rep );
00242 plotter -> addDataRep ( rep );
00243 plotter -> setAutoRanging ( true );
00244
00245 return plotter;
00246 }
00247
00248 PlotterBase *
00249 DisplayController::
00250 createDisplay ( const std::string & name,
00251 const DataSource & tuple,
00252 const std::vector< std::string > & bindings ) const
00253 {
00254 DataRepFactory * factory = DataRepFactory::instance ();
00255 DataRep * proto = factory->prototype ( name );
00256 assert ( proto != 0 );
00257
00258 PlotterBase * plotter = createPlotter ( proto );
00259
00260 addDataRep ( plotter, name, &tuple, bindings );
00261
00262 #ifdef HAVE_CFITSIO
00263 FitsController * controller = FitsController::instance ();
00264 controller -> checkForImage ( plotter, tuple, bindings );
00265 #endif
00266
00267 plotter -> autoScale ();
00268
00269 return plotter;
00270 }
00271
00272 PlotterBase * DisplayController::createPlotter ( const DataRep * rep ) const
00273 {
00274 PlotterFactory * factory = PlotterFactory::instance ();
00275 PlotterBase * plotter = 0;
00276 try {
00277 plotter = factory -> create ( "XyPlotter" );
00278 if ( rep -> hasAxis ( Axes::Z ) ) {
00279 plotter -> setEnableZ ( true );
00280 }
00281 }
00282 catch ( const FactoryException & ) {
00283 assert ( false );
00284 }
00285 return plotter;
00286 }
00287
00290 DataRep *
00291 DisplayController::
00292 addDataRep ( PlotterBase * plotter,
00293 const std::string & type,
00294 const DataSource * tuple,
00295 const std::vector < std::string > & bindings ) const
00296 {
00297
00298 bool yes = isCompatible ( plotter, type );
00299 if ( ! yes ) return 0;
00300
00301 DataRepController * controller = DataRepController::instance ();
00302 DataRep * rep = controller->createDataRep ( type, tuple, bindings );
00303
00304 addDataRep ( plotter, rep );
00305
00306 return rep;
00307 }
00308
00309 void
00310 DisplayController::
00311 stackDataRep ( PlotterBase * plotter, DataRep * rep ) const
00312 {
00313 XyPlotter * xyplotter = dynamic_cast < XyPlotter * > ( plotter );
00314 xyplotter -> addDataRepStacked ( rep );
00315 }
00316
00317 DataRep *
00318 DisplayController::
00319 addDataRepStacked ( PlotterBase * plotter,
00320 const std::string & type,
00321 const DataSource * tuple,
00322 const std::vector < std::string > & bindings ) const
00323 {
00324 bool yes = isCompatible ( plotter, type );
00325 if ( ! yes ) return 0;
00326
00327 DataRepController * controller = DataRepController::instance ();
00328 DataRep * rep = controller->createDataRep ( type, tuple, bindings );
00329
00330 stackDataRep ( plotter, rep );
00331
00332 return rep;
00333 }
00334
00335 LineDataRep *
00336 DisplayController::
00337 addLineRep ( PlotterBase * plotter, hippodraw::Axes::Type axis, double value )
00338 {
00339 LineDataRep * rep = new LineDataRep ( axis, value );
00340 addDataRep ( plotter, rep );
00341
00342 return rep;
00343 }
00344
00345 LineDataRep *
00346 DisplayController::
00347 addLineRep ( PlotterBase * plotter, const std::string & axis, double value )
00348 {
00349 Axes::Type type = Axes::convert ( axis );
00350
00351 return addLineRep ( plotter, type, value );
00352 }
00353
00354 void
00355 DisplayController::
00356 fixLogIfBinned ( const PlotterBase * plotter, DataRep * rep ) const
00357 {
00358 setBinner ( plotter, rep, Axes::X );
00359 setBinner ( plotter, rep, Axes::Y );
00360 }
00361
00365 void
00366 DisplayController::
00367 addDataRep ( PlotterBase * plotter, DataRep * rep ) const
00368 {
00369 if ( plotter -> getNumDataReps () > 0 ) {
00370 fixLogIfBinned ( plotter, rep );
00371 }
00372
00373 plotter->addDataRep ( rep );
00374
00375 if ( !rep->hasZeroRows() ){
00376 plotter->checkAxisScaling ( );
00377 }
00378
00379 }
00380
00383 bool
00384 DisplayController::
00385 isCompatible ( const PlotterBase * plotter,
00386 const std::string & datarep ) const
00387 {
00388 DataRepFactory * factory = DataRepFactory::instance ();
00389 DataRep * proto = factory->prototype ( datarep );
00390
00391 bool yes = true;
00392
00393 if ( proto -> hasAxis ( Axes::Z ) ) {
00394 yes = plotter->hasAxis ( Axes::Z );
00395 }
00396
00397 return yes;
00398 }
00399
00400 void
00401 DisplayController::
00402 removeTextObservers ( const std::vector < const ViewBase * > & views )
00403 {
00404 #ifdef ITERATOR_MEMBER_DEFECT
00405 std::
00406 #endif
00407 vector < const ViewBase * > ::const_iterator iter = views.begin();
00408
00409 while ( iter != views.end() ) {
00410
00411
00412
00413
00414 const ViewBase * curview = ( * iter++ );
00415 PlotterBase * curplotter = curview->getPlotter ();
00416
00417 TextPlotter * textPlotter
00418 = dynamic_cast < TextPlotter * > ( curplotter );
00419
00420 if ( textPlotter ){
00421 const DataRep * target = textPlotter->getParentDataRep();
00422 if ( target ){
00423 DataRep * tar = const_cast < DataRep * > ( target );
00424 tar->removeObserver ( textPlotter );
00425 }
00426 }
00427 }
00428 }
00429
00430 void
00431 DisplayController::
00432 addTextViewToList ( std::vector < const ViewBase * > & dest,
00433 const std::vector < const ViewBase * > & src )
00434 {
00435 std::vector < const ViewBase * > ::const_iterator first = src.begin();
00436 while ( first != src.end() ) {
00437 const ViewBase * view = *first++;
00438
00439 vector < const ViewBase * > :: iterator i
00440 = find ( dest.begin(), dest.end (), view );
00441 if ( i != dest.end() ) continue;
00442
00443 PlotterBase * plotter = view->getPlotter ();
00444 TextPlotter * text_plotter = dynamic_cast < TextPlotter * > ( plotter );
00445 if ( text_plotter == 0 ) continue;
00446
00447 const DataRep * datarep = text_plotter->getParentDataRep ();
00448 bool add_to_list = false;
00449 for ( i = dest.begin (); i != dest.end(); ++i ) {
00450 const ViewBase * view = *i;
00451 PlotterBase * plotter = view->getPlotter ();
00452 int num = plotter->getNumDataReps ();
00453 for ( int j = 0; j < num; j++ ) {
00454 DataRep * rep = plotter->getDataRep ( j );
00455 if ( rep == datarep ) {
00456 add_to_list = true;
00457 break;
00458 }
00459 }
00460 if ( add_to_list ) break;
00461 }
00462 if ( add_to_list ) dest.push_back ( view );
00463 }
00464 }
00465
00466 bool
00467 DisplayController::
00468 isAxisBinned ( PlotterBase * plotter,
00469 const std::string & axis )
00470 {
00471 bool yes = false;
00472
00473 int index = plotter->activePlotIndex ( );
00474 if ( index < 0 ) {
00475 FunctionController * controller = FunctionController::instance();
00476 index = controller->getUniqueNonFunctionIndex ( plotter );
00477 }
00478 if ( index >= 0 ) {
00479 ProjectorBase * projector = plotter->activeProjector ();
00480 yes = projector->isAxisBinned ( axis );
00481 }
00482
00483 return yes;
00484 }
00485
00486 ViewBase * DisplayController::createTextView ( const ViewFactory * v_factory,
00487 PlotterBase * plotter,
00488 const std::string & name,
00489 const std::string & text)
00490 {
00491 int index = activeDataRepIndex ( plotter );
00492 DataRep * datarep = plotter->getDataRep ( index );
00493 ViewBase * view = createTextView ( v_factory, datarep, name, text );
00494 assert ( view != 0 );
00495
00496 return view;
00497 }
00498
00499 const vector < string > &
00500 DisplayController::
00501 getTextTypes () const
00502 {
00503 TextRepFactory * text_factory = TextRepFactory::instance ();
00504
00505 return text_factory->names ();
00506 }
00507
00508 DataRep * DisplayController::createTextDataRep ( const std::string & name,
00509 const std::string & text)
00510 {
00511 TextRepFactory * text_factory = TextRepFactory::instance ();
00512 RepBase * textrep = text_factory->create ( name );
00513 assert ( textrep != 0 );
00514
00515 textrep->setText ( text );
00516 DataRep * datarep = new TextDataRep ( textrep );
00517
00518 return datarep;
00519 }
00520
00521 PlotterBase *
00522 DisplayController::createTextPlotter ( DataRep * datarep,
00523 const std::string & name,
00524 const std::string & text)
00525 {
00526 DataRep * textdatarep = createTextDataRep ( name, text );
00527 TextPlotter * plotter = new TextPlotter ( );
00528 plotter->addDataRep ( textdatarep );
00529 plotter->setParentDataRep ( datarep );
00530
00531 return plotter;
00532 }
00533
00534 ViewBase * DisplayController::createTextView ( const ViewFactory * v_factory,
00535 DataRep * datarep,
00536 const std::string & name,
00537 const std::string & text)
00538 {
00539 PlotterBase * plotter = createTextPlotter ( datarep, name, text );
00540
00541 return v_factory->createView ( plotter );
00542 }
00543
00544 int DisplayController::
00545 activeDataRepIndex ( const PlotterBase * plotter ) const
00546 {
00547 int index = plotter->activePlotIndex ();
00548 if ( index < 0 ) {
00549 FunctionController * controller = FunctionController::instance ();
00550 index = controller->getUniqueNonFunctionIndex ( plotter );
00551 }
00552 return index;
00553 }
00554
00555 DataRep *
00556 DisplayController::
00557 activeDataRep ( const PlotterBase * plotter ) const
00558 {
00559 DataRep * rep = 0;
00560 int index = activeDataRepIndex ( plotter );
00561 if ( index >= 0 ) {
00562 rep = plotter -> getDataRep ( index );
00563 }
00564
00565 return rep;
00566 }
00567
00568 void
00569 DisplayController::
00570 setActiveDataRepIndex ( PlotterBase * plotter, int index )
00571 {
00572 plotter -> setActivePlot ( index, true );
00573 }
00574
00575 const vector < string > &
00576 DisplayController::
00577 axisBindings ( const PlotterBase * plotter ) const
00578 {
00579
00580 NTupleProjector * ntProjector =
00581 dynamic_cast <NTupleProjector *> ( plotter->activeProjector() );
00582
00583 if ( ntProjector == 0 ) return m_null_vector;
00584
00585 return ntProjector->getAxisBindings ();
00586 }
00587
00588 const vector < string > &
00589 DisplayController::bindingOptions ( const PlotterBase * plotter,
00590 int index )
00591 {
00592 DataRep * rep = plotter->getDataRep ( index );
00593 DataRepController * controller = DataRepController::instance ();
00594
00595 return controller->bindingOptions ( rep );
00596 }
00597
00598 const vector < string > &
00599 DisplayController::
00600 bindingOptions ( const std::string & type )
00601 {
00602 DataRepFactory * factory = DataRepFactory::instance ();
00603 DataRep * rep = factory -> prototype ( type );
00604 DataRepController * controller = DataRepController::instance ();
00605
00606 return controller -> bindingOptions ( rep );
00607 }
00608
00609 const vector < string > &
00610 DisplayController::
00611 axisBindings ( const PlotterBase * plotter, int index ) const
00612 {
00613 assert ( index < plotter->getNumDataReps () );
00614
00615 ProjectorBase * pbase = plotter->getProjector ( index );
00616
00617 NTupleProjector * ntProjector =
00618 dynamic_cast <NTupleProjector *> ( pbase );
00619
00620 if ( ntProjector == 0 ) return m_null_vector;
00621
00622 return ntProjector->getAxisBindings ();
00623 }
00624
00625 int
00626 DisplayController::
00627 getNumberOfEntries ( const PlotterBase * plotter, int index ) const
00628 {
00629 assert ( index < plotter->getNumDataReps () );
00630
00631 ProjectorBase * projector = plotter -> getProjector ( index );
00632
00633 return projector -> getNumberOfEntries ();
00634 }
00635
00636 double
00637 DisplayController::
00638 getAverage ( const PlotterBase * plotter,
00639 const std::string & axis, int index ) const
00640 {
00641 Axes::Type a = Axes::convert ( axis );
00642
00643 return getAverage ( plotter, a, index );
00644 }
00645
00646 double
00647 DisplayController::
00648 getAverage ( const PlotterBase * plotter,
00649 hippodraw::Axes::Type axis,
00650 int index ) const
00651 {
00652 assert ( index < plotter -> getNumDataReps () );
00653
00654 ProjectorBase * projector = plotter -> getProjector ( index );
00655
00656 return projector -> getAverage ( axis );
00657 }
00658
00659 double
00660 DisplayController::
00661 getRMS ( const PlotterBase * plotter,
00662 const std::string & axis, int index ) const
00663 {
00664 Axes::Type a = Axes::convert ( axis );
00665
00666 return getRMS ( plotter, a, index );
00667 }
00668
00669 double
00670 DisplayController::
00671 getRMS ( const PlotterBase * plotter,
00672 hippodraw::Axes::Type axis,
00673 int index ) const
00674 {
00675 assert ( index < plotter -> getNumDataReps () );
00676
00677 ProjectorBase * projector = plotter -> getProjector ( index );
00678
00679 return projector -> getRMS ( axis );
00680 }
00681
00682 const string & DisplayController::getType ( const PlotterBase * plotter,
00683 int index ) const
00684 {
00685 DataRep * datarep = plotter->getDataRep ( index );
00686
00687 return datarep->name ();
00688 }
00689
00690 ProjectorBase *
00691 DisplayController::getProjector ( const PlotterBase * plotter ) const
00692 {
00693 DataRep * datarep = plotter->selectedDataRep ();
00694
00695 if ( datarep == 0 ) return 0;
00696
00697 return datarep->getProjector ();
00698 }
00699
00703 NTupleProjector *
00704 DisplayController::getBindingProjector ( const PlotterBase * plotter ) const
00705 {
00706 ProjectorBase * projbase = getProjector ( plotter );
00707 if ( projbase != 0 ) {
00708 NTupleProjector * projector
00709 = dynamic_cast < NTupleProjector * > ( projbase );
00710 return projector;
00711 }
00712
00713
00714
00715
00716 int number = plotter->getNumDataReps ();
00717 for ( int i = 0; i < number; i++ ) {
00718 DataRep * rep = plotter->getDataRep ( i );
00719 FunctionRep * frep = dynamic_cast < FunctionRep * > ( rep );
00720 if ( frep != 0 ) continue;
00721 if ( projbase == 0 ) {
00722 projbase = rep->getProjector ();
00723 }
00724 else {
00725 return 0;
00726 }
00727 }
00728 NTupleProjector * projector
00729 = dynamic_cast < NTupleProjector * > ( projbase );
00730
00731 return projector;
00732 }
00733
00734 void DisplayController::setNTuple ( PlotterBase * plotter,
00735 const NTuple * ntuple ) const
00736 {
00737 NTupleProjector * projector = getBindingProjector ( plotter );
00738 if ( projector == 0 ) return;
00739
00740 projector->setNTuple ( ntuple );
00741 NTuple * nt = const_cast < NTuple * > ( ntuple );
00742 nt->addObserver ( projector );
00743 DataRep * datarep = plotter->selectedDataRep ();
00744
00745 datarep->notifyObservers ();
00746 }
00747
00748 const DataSource *
00749 DisplayController::
00750 getNTuple ( const PlotterBase * plotter ) const
00751 {
00752 NTupleProjector * projector = getBindingProjector ( plotter );
00753 if ( projector == 0 ) return 0;
00754
00755 return projector->getNTuple ();
00756 }
00757
00758
00759 DataSource *
00760 DisplayController::
00761 getNTuple ( const PlotterBase * plotter, int index )
00762 {
00763 DataRep * rep = plotter->getDataRep ( index );
00764 if ( ! rep->hasNTupleBindings () ) return 0;
00765 ProjectorBase * pbase = rep->getProjector ();
00766 NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00767
00768 return projector -> getNTuple ();
00769 }
00770
00771 void
00772 DisplayController::
00773 setIntervalCount ( const PlotterBase * plotter, unsigned int count )
00774 {
00775 int i = activeDataRepIndex ( plotter );
00776 if ( i < 0 ) return;
00777 DataSource * ds = getNTuple ( plotter, i );
00778 NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
00779
00780 if ( ntuple != 0 ) ntuple->setIntervalCount ( count );
00781 }
00782
00783 void
00784 DisplayController::
00785 setIntervalEnabled ( const PlotterBase * plotter, bool yes )
00786 {
00787 int i = activeDataRepIndex ( plotter );
00788 if ( i < 0 ) return;
00789 DataSource * ds = getNTuple ( plotter, i );
00790 NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
00791
00792 if ( ntuple != 0 ) ntuple->setIntervalEnabled ( yes );
00793 }
00794
00795 void
00796 DisplayController::
00797 setAllIntervalEnabled ( const PlotterBase * plotter, bool yes )
00798 {
00799 int number = plotter->getNumDataReps ();
00800 for ( int i = 0; i < number; i++ ) {
00801 DataSource * ds = getNTuple ( plotter, i );
00802 NTuple * ntuple = dynamic_cast < NTuple * > ( ds );
00803 if ( ntuple != 0 ) ntuple->setIntervalEnabled ( yes );
00804 }
00805 }
00806
00807 bool DisplayController::areDataSourcesSaved ( const PlotterBase * plotter )
00808 {
00809 bool yes = true;
00810 DataSourceController * controller = DataSourceController::instance ();
00811
00812 int number = plotter->getNumDataReps ();
00813 for ( int i = 0; i < number; i++ ) {
00814 const string & name = getDataSourceName ( plotter, i );
00815 if ( name.empty () ) continue;
00816
00817 yes = controller->isSaved ( name );
00818 if ( yes == false ) break;
00819 }
00820
00821 return yes;
00822 }
00823
00824 bool DisplayController::hasNTupleBindings ( const PlotterBase * plotter,
00825 int index )
00826 {
00827 assert ( ! ( index < 0 ) );
00828 DataRep * rep = plotter->getDataRep ( index );
00829
00830 return rep->hasNTupleBindings ();
00831 }
00832
00833 const string &
00834 DisplayController::getDataSourceName ( const PlotterBase * plotter,
00835 int index )
00836 {
00837 DataRep * datarep = plotter->getDataRep ( index );
00838 ProjectorBase * pbase = datarep->getProjector ();
00839 NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00840 if ( projector == 0 ) return m_null_string;
00841
00842 return projector->getNTupleName ();
00843 }
00844
00845 const vector < string > &
00846 DisplayController::getDataSourceLabels ( const PlotterBase * plotter,
00847 int index )
00848 {
00849 DataRep * datarep = plotter->getDataRep ( index );
00850 ProjectorBase * pbase = datarep->getProjector ();
00851 NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00852 if ( projector == 0 ) return m_null_vector;
00853
00854 const DataSource * tuple = projector->getNTuple ();
00855
00856 return tuple->getLabels ();
00857 }
00858
00859 DataRep *
00860 DisplayController::
00861 getUniqueWithNTupleBindings ( const PlotterBase * plotter )
00862 {
00863 DataRep * rep = 0;
00864 int active = plotter -> activePlotIndex ();
00865
00866 if ( active < 0 ) {
00867 int count = 0;
00868 int number = plotter -> getNumDataReps ();
00869 for ( int i = 0; i < number; i++ ) {
00870 DataRep * trep = plotter -> getDataRep ( i );
00871 if ( trep -> hasNTupleBindings () ) {
00872 if ( count == 0 ) {
00873 rep = trep;
00874 count ++;
00875 }
00876 else {
00877 rep = 0;
00878 break;
00879 }
00880 }
00881 }
00882 }
00883 else {
00884 rep = plotter ->getDataRep ( active );
00885 if ( rep ->hasNTupleBindings () == false ) {
00886 rep = 0;
00887 }
00888 }
00889
00890 return rep;
00891 }
00892
00893 void DisplayController::setAxisBinding ( PlotterBase * plotter,
00894 const std::string & axis,
00895 const std::string & label )
00896 {
00897 DataRep * rep = plotter -> getTarget ();
00898
00899 if ( rep != 0 ) {
00900 rep -> setAxisBinding ( axis, label );
00901 Axes::Type a = Axes::X;
00902 if ( axis[0] == 'Y' ) a = Axes::Y;
00903 plotter -> setAutoRanging ( a, true );
00904 plotter -> autoScale ();
00905 }
00906 }
00907
00908 void DisplayController::
00909 setAxisBindings ( PlotterBase * plotter,
00910 const std::vector< std::string > & labels ) const
00911 {
00912 NTupleProjector * projector = getBindingProjector ( plotter );
00913 if ( projector == 0 ) return;
00914
00915 projector->setAxisBindings ( labels );
00916 plotter->setAutoRanging ( true );
00917
00918 }
00919
00920 bool
00921 DisplayController::
00922 isDataValid ( const PlotterBase * plotter ) const
00923 {
00924 bool valid = true;
00925 const DataRep * rep = plotter -> getTarget ();
00926 if ( rep != 0 ) {
00927 valid = isDataValid ( rep );
00928 }
00929
00930 return valid;
00931 }
00932
00933 bool
00934 DisplayController::
00935 isDataValid ( const DataRep * rep ) const
00936 {
00937 bool valid = true;
00938 ProjectorBase * base = rep -> getProjector ();
00939 const NTupleProjector * projector
00940 = dynamic_cast < const NTupleProjector * > ( base );
00941 if ( projector != 0 ) {
00942 valid = projector -> isDataValid ();
00943 }
00944
00945 return valid;
00946 }
00947
00948 bool
00949 DisplayController::
00950 getLog ( const PlotterBase * plotter,
00951 const std::string & axis) const
00952 {
00953 Axes::Type at = Axes::convert ( axis );
00954 return getLog ( plotter, at );
00955 }
00956
00958 bool
00959 DisplayController::
00960 getLog ( const PlotterBase * plotter, hippodraw::Axes::Type axis ) const
00961 {
00962 assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
00963
00964 XYTransform * xy_transform
00965 = dynamic_cast < XYTransform *> ( plotter->getTransform () );
00966
00967 if ( xy_transform == 0 ) return false;
00968
00969 TransformBase * transform = 0;
00970
00971 if ( axis == Axes::X ){
00972 transform = xy_transform->xTransform ();
00973 }
00974 if ( axis == Axes::Y ){
00975 transform = xy_transform->yTransform();
00976 }
00977 if ( axis == Axes::Z ){
00978 transform = xy_transform->zTransform();
00979 }
00980
00981 assert ( transform );
00982
00983 const string & name = transform->name ();
00984
00985 return name == "Log";
00986 }
00987 void
00988 DisplayController::
00989 setBinner ( const PlotterBase * plotter,
00990 DataRep * datarep,
00991 hippodraw::Axes::Type axis ) const
00992 {
00993 ProjectorBase * projbase = datarep->getProjector ();
00994
00995 BinningProjector * projector
00996 = dynamic_cast< BinningProjector * > ( projbase );
00997 if ( projector == 0 ) return;
00998
00999 if ( axis == Axes::Y &&
01000 projector->isAxisBinned ( "Y" ) == false ) return;
01001
01002 const Range & range = plotter -> getRange ( axis, false );
01003 BinnerAxis * binner = 0;
01004
01005 BinnerAxisFactory * binner_factory = BinnerAxisFactory::instance ();
01006 AxisModelBase * model = plotter -> getAxisModel ( axis );
01007
01008 if ( model->isLog() ) {
01009 binner = binner_factory -> create ( "BinnerLog" );
01010 } else {
01011 binner = binner_factory -> create ( "BinnerLinear" );
01012 }
01013
01014 binner->setRange ( range, false );
01015 projector->setBinnerOn ( binner, axis );
01016 }
01017
01021 void
01022 DisplayController::
01023 setBinner ( PlotterBase * plotter,
01024 hippodraw::Axes::Type axis,
01025 AxisModelBase * model )
01026 {
01027 int number = plotter->getNumDataReps ();
01028 for ( int i = 0; i < number; i++ ) {
01029 DataRep * datarep = plotter->getDataRep ( i );
01030 setBinner ( plotter, datarep, axis );
01031 }
01032
01033 }
01034
01035 void
01036 DisplayController::
01037 setAxisModel ( PlotterBase * plotter,
01038 hippodraw::Axes::Type axis,
01039 const std::string & type )
01040 {
01041 AxisModelBase * model = plotter->getAxisModel ( axis );
01042
01043 if ( model != 0 ) {
01044 AxisModelBase * temp = 0;
01045
01046 if ( type == "Linear" ) {
01047
01048 if ( !( model->isLog() ) ) return;
01049 temp = new AxisModelLinear ( *model );
01050
01051 }
01052 else if ( type == "Log" ) {
01053
01054 if ( model->isLog () ) return;
01055 double pos = plotter->getPosRange ( axis );
01056 model->setRangePos ( pos );
01057 temp = new AxisModelLog ( *model );
01058
01059 }
01060
01061 assert ( temp );
01062
01063 swap ( temp, model );
01064
01065 plotter->setAxisModel ( model, axis );
01066
01067 setBinner ( plotter, axis, model );
01068
01069
01070 delete temp;
01071 }
01072 }
01073
01074 void
01075 DisplayController::
01076 setLog ( PlotterBase * plotter,
01077 const std::string & axis,
01078 bool flag )
01079 {
01080 Axes::Type at = Axes::convert ( axis );
01081 setLog ( plotter, at, flag );
01082 }
01083
01085 void
01086 DisplayController::
01087 setLog ( PlotterBase * plotter,
01088 hippodraw::Axes::Type axis,
01089 bool flag )
01090 {
01091 assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
01092
01093 TransformBase * current = plotter->getTransform ();
01094
01095 XYTransform * xy_transform = dynamic_cast < XYTransform *> ( current );
01096
01097 if ( xy_transform != 0 ) {
01098 setLog ( plotter, axis, flag, xy_transform );
01099 return;
01100 }
01101 assert ( axis == Axes::Z );
01102 BinaryTransform * b_transform
01103 = dynamic_cast < BinaryTransform * > ( current );
01104 string type;
01105 if ( flag ) type = "Log";
01106 else type = "Linear";
01107
01108 setAxisModel ( plotter, Axes::Z , type );
01109
01110 TransformFactory * factory = TransformFactory::instance ();
01111 TransformBase * transform = factory -> createTransform ( type );
01112
01113 b_transform -> setZTransform ( transform );
01114 plotter -> setTransform ( b_transform );
01115 }
01116
01117 void
01118 DisplayController::
01119 setLog ( PlotterBase * plotter,
01120 hippodraw::Axes::Type axis,
01121 bool flag,
01122 XYTransform * xy_transform )
01123 {
01124 TransformBase * transform = xy_transform->xTransform ();
01125
01126 string x_trans = transform->name ();
01127 transform = xy_transform->yTransform ();
01128 string y_trans = transform->name ();
01129 transform = xy_transform->zTransform ();
01130 string z_trans = transform->name ();
01131
01132 if( flag ){
01133 if( axis == Axes::X ){
01134 x_trans = "Log";
01135 setAxisModel ( plotter, Axes::X, x_trans );
01136 }
01137 if( axis == Axes::Y ){
01138 y_trans = "Log";
01139 setAxisModel ( plotter, Axes::Y, y_trans );
01140 }
01141 if( axis == Axes::Z ){
01142 z_trans = "Log";
01143 setAxisModel ( plotter, Axes::Z, z_trans );
01144 }
01145 }
01146
01147 if( !flag ){
01148 if( axis == Axes::X ) {
01149 x_trans = "Linear";
01150 setAxisModel ( plotter, Axes::X, x_trans );
01151 }
01152 if( axis == Axes::Y ) {
01153 y_trans = "Linear";
01154 setAxisModel ( plotter, Axes::Y , y_trans );
01155 }
01156 if( axis == Axes::Z ) {
01157 z_trans = "Linear";
01158 setAxisModel ( plotter, Axes::Z , z_trans );
01159 }
01160 }
01161
01162 TransformFactory * factory = TransformFactory::instance ();
01163 string t_name = x_trans + " " + y_trans + " " + z_trans;
01164 transform = factory->createTransform ( t_name );
01165
01166 plotter->setTransform ( transform );
01167 delete transform;
01168 }
01169
01170
01171 void DisplayController::setTransform ( PlotterBase * plotter,
01172 const std::string & name )
01173 {
01174 TransformFactory * factory = TransformFactory::instance ();
01175 TransformBase * transform = factory->createTransform ( name );
01176
01177 try {
01178 plotter->setTransform ( transform );
01179 delete transform;
01180 } catch (PlotterException & eObj) {
01181 delete transform;
01182 throw eObj;
01183 }
01184 }
01185
01186 void DisplayController::setTransform ( PlotterBase * plotter,
01187 const std::string & x,
01188 const std::string & y )
01189 {
01190 TransformFactory * factory = TransformFactory::instance ();
01191 const string name = x + " " + y;
01192 TransformBase * transform = factory->createTransform ( name );
01193
01194 plotter->setTransform ( transform );
01195
01196 delete transform;
01197 }
01198
01199 void DisplayController:: remove ( PlotterBase * plotter )
01200 {
01201 delete plotter;
01202 }
01203
01204 float DisplayController::pointSize ( const PlotterBase * plotter ) const
01205 {
01206 RepBase * rep = plotter->representation ();
01207
01208 return rep->size ();
01209 }
01210
01211 bool
01212 DisplayController::
01213 hasSymbolRep ( const PlotterBase * plotter ) const
01214 {
01215 RepBase * rep = plotter -> representation ();
01216 SymbolPointRep * symrep = dynamic_cast < SymbolPointRep * > ( rep );
01217
01218 return symrep != 0;
01219 }
01220
01221 bool
01222 DisplayController::
01223 hasLineRep ( const PlotterBase * plotter ) const
01224 {
01225 bool yes = false;
01226
01227 RepBase * rep = plotter -> representation ();
01228 ColumnPointRep * colrep = dynamic_cast < ColumnPointRep * > ( rep );
01229
01230 if ( colrep != 0 ) {
01231 yes = true;
01232 }
01233 else {
01234 LinePointRep * linerep = dynamic_cast < LinePointRep * > ( rep );
01235 yes = linerep != 0;
01236 }
01237
01238 return yes;
01239 }
01240
01241 unsigned int
01242 DisplayController::
01243 getRepStyle ( const PlotterBase * plotter ) const
01244 {
01245 RepBase * rep = plotter -> representation ();
01246
01247 return rep -> getStyle ();
01248 }
01249
01250 void DisplayController::setRepSize ( PlotterBase * plotter, float size )
01251 {
01252 DataRep * datarep = plotter->selectedDataRep ();
01253
01254 datarep->setRepSize ( size );
01255 }
01256
01257 void
01258 DisplayController::
01259 setRepresentation ( PlotterBase * plotter, const std::string & point_rep )
01260 {
01261 int index = activeDataRepIndex ( plotter );
01262 if ( index >= 0 ) {
01263 DataRep * datarep = plotter -> getDataRep ( index );
01264 assert ( datarep );
01265 PointRepFactory * factory = PointRepFactory::instance ();
01266 RepBase * rep = factory -> create ( point_rep );
01267 const Color & color = datarep -> getRepColor ();
01268 rep -> setColor ( color );
01269 datarep -> setRepresentation ( rep );
01270 }
01271 }
01272
01273 void
01274 DisplayController::
01275 setRange ( PlotterBase * plotter,
01276 hippodraw::Axes::Type axis,
01277 const Range & range )
01278 {
01279 plotter->setRange ( axis, range );
01280
01281 plotter->setAutoRanging ( axis, false );
01282 }
01283
01284 void
01285 DisplayController::
01286 setBinWidth ( PlotterBase * plotter,
01287 const std::string & axis,
01288 double width )
01289 {
01290 Axes::Type at = Axes::convert ( axis );
01291
01292 setBinWidth ( plotter, at, width );
01293 }
01294
01295 void
01296 DisplayController::
01297 setBinWidth ( DataRep * datarep,
01298 hippodraw::Axes::Type axis,
01299 double width )
01300 {
01301 const list < Observer * > & obs_list = datarep -> getObservers ();
01302 list < Observer * >::const_iterator first = obs_list.begin();
01303 while ( first != obs_list.end () ) {
01304 Observer * obs = *first++;
01305 PlotterBase * plotter = dynamic_cast < PlotterBase * > ( obs );
01306 if ( plotter != 0 ) {
01307 plotter -> autoScale ();
01308 datarep -> setBinWidth ( axis, width );
01309 plotter -> setAutoRanging ( axis, false );
01310 break;
01311 }
01312 }
01313 }
01314
01315 void
01316 DisplayController::
01317 setBinWidth ( PlotterBase * plotter,
01318 hippodraw::Axes::Type axis,
01319 double width )
01320 {
01321 bool widths_are_same = false;
01322
01323 int index = plotter->activePlotIndex ();
01324
01325 if ( index < 0 ) {
01326 int number = plotter->getNumDataReps ();
01327 for ( int i = 0; i < number; i++ ) {
01328 ProjectorBase * projector = plotter->getProjector ( i );
01329 projector->setBinWidth ( axis, width );
01330 }
01331
01332 widths_are_same = true;
01333 }
01334 else {
01335 ProjectorBase * projector = plotter->getProjector ( index );
01336 projector->setBinWidth ( axis, width );
01337 }
01338
01339 plotter->setAutoRanging ( axis, false );
01340 }
01341
01344 void DisplayController::setBinWidth ( PlotterBase * plotter,
01345 const std::string & axis,
01346 int parm,
01347 bool dragging )
01348 {
01349 bool widths_are_same = false;
01350
01351 Axes::Type at = Axes::X;
01352 if ( axis == "Y" ) at = Axes::Y;
01353 if ( axis == "Z" ) at = Axes::Z;
01354 plotter->setAutoRanging ( at, false );
01355
01356 int index = plotter->activePlotIndex ();
01357
01358 if ( index < 0 ) {
01359 int number = plotter->getNumDataReps ();
01360 for ( int i = 0; i < number; i++ ) {
01361 ProjectorBase * projector = plotter->getProjector ( i );
01362 projector->setBinWidth ( axis, parm, dragging );
01363 }
01364
01365 widths_are_same = true;
01366 }
01367 else {
01368 ProjectorBase * projector = plotter->getProjector ( index );
01369 projector->setBinWidth ( axis, parm, dragging );
01370 }
01371 }
01372
01377 void
01378 DisplayController::
01379 setOffset ( PlotterBase * plotter,
01380 const std::string & axis,
01381 int parm,
01382 bool dragging )
01383 {
01384 bool widths_are_same = false;
01385
01386 Axes::Type at = Axes::X;
01387 if ( axis == "Y" ) at = Axes::Y;
01388 if ( axis == "Z" ) at = Axes::Z;
01389 plotter->setAutoRanging ( at, false );
01390
01391 int index = plotter->activePlotIndex ();
01392
01393 if ( index < 0 ) {
01394 int number = plotter->getNumDataReps ();
01395 for ( int i = 0; i < number; i++ ) {
01396 ProjectorBase * projector = plotter->getProjector ( i );
01397 projector->setOffset ( axis, parm, dragging );
01398 }
01399
01400 widths_are_same = true;
01401 }
01402 else {
01403 ProjectorBase * projector = plotter->getProjector ( index );
01404 projector->setOffset ( axis, parm, dragging );
01405 }
01406
01407 }
01408
01409 void
01410 DisplayController::
01411 setOffset ( PlotterBase * plotter,
01412 hippodraw::Axes::Type axis,
01413 double offset )
01414 {
01415 bool widths_are_same = false;
01416
01417 int index = plotter->activePlotIndex ();
01418
01419 if ( index < 0 ) {
01420 int number = plotter->getNumDataReps ();
01421 for ( int i = 0; i < number; i++ ) {
01422 ProjectorBase * projector = plotter->getProjector ( i );
01423 projector->setOffset ( axis, offset );
01424 }
01425
01426 widths_are_same = true;
01427 }
01428 else {
01429 ProjectorBase * projector = plotter->getProjector ( index );
01430 projector->setOffset ( axis, offset );
01431 }
01432
01433 }
01434
01435 void
01436 DisplayController::
01437 setErrorDisplayed ( const PlotterBase * plotter,
01438 hippodraw::Axes::Type axis,
01439 bool state ) const
01440 {
01441 int index = activeDataRepIndex ( plotter );
01442 if ( index >= 0 ) {
01443 DataRep * rep = plotter -> getDataRep ( index );
01444 rep -> setErrorDisplay ( axis, state );
01445 }
01446 }
01447
01448 void
01449 DisplayController::
01450 createNTuple ( const PlotterBase * plotter )
01451 {
01452 int index = plotter -> activePlotIndex ();
01453 if ( index < 0 ) return;
01454
01455 NTuple * ntuple = plotter -> createNTuple ();
01456 DataSourceController::instance () -> registerNTuple ( ntuple );
01457 }