00001
00013
00014 #ifdef HAVE_CONFIG_H
00015 #include "config.h"
00016 #else
00017
00018
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 ();
00206 if ( rep != 0 ) {
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 ) {
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
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 );
00332 vector < double > & y1 = ntuple1 -> getColumn ( 1 );
00333 vector < double > & deltaX1 = ntuple1 -> getColumn (2);
00334
00335 vector < double > & x2 = ntuple2 -> getColumn ( 0 );
00336 vector < double > & y2 = ntuple2 -> getColumn ( 1 );
00337 vector < double > & deltaX2 = ntuple2 -> getColumn (2);
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() ) {
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
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
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
00583
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;
00613
00614 PlotterBase * plotter = view->getPlotter ();
00615 TextPlotter * text_plotter = dynamic_cast < TextPlotter * > ( plotter );
00616 if ( text_plotter == 0 ) continue;
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;
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
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
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
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
00906
00907
00908
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;
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 ) {
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 {
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 {
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;
01258 temp = new AxisModelLinear ( *model );
01259
01260 }
01261 else if ( type == "Log" ) {
01262
01263 if ( model->isLog () ) return;
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
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 ){
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
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;
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;
01402 } catch (PlotterException & eObj) {
01403 delete transform;
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;
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
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;
01656 temp = new AxisModelLinear ( *model );
01657
01658 }
01659 else if ( type == "Log" ) {
01660
01661 if ( model->isLog () ) return;
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
01681 delete temp;
01682 }
01683 }