00001
00013
00014 #ifdef HAVE_CONFIG_H
00015 #include "config.h"
00016 #endif
00017
00018
00019 #ifdef _MSC_VER
00020 #include "msdevstudio/MSconfig.h"
00021 #endif
00022
00023 #include "CutPlotter.h"
00024
00025 #include "CompositePlotter.h"
00026
00027 #include "datareps/DataRep.h"
00028
00029 #include "datasrcs/DataSource.h"
00030 #include "datasrcs/TupleCut.h"
00031
00032 #include "projectors/NTupleProjector.h"
00033
00034 #include "reps/CutRangeRep.h"
00035 #include "reps/ColorBoxPointRep.h"
00036
00037 #include <algorithm>
00038 #include <functional>
00039
00040 #include <cassert>
00041
00042 using std::list;
00043 using std::mem_fun;
00044 using std::swap;
00045 using std::string;
00046 using std::vector;
00047
00048 using namespace hippodraw;
00049
00050 CutPlotter::
00051 CutPlotter ( const std::string & name )
00052 : XyPlotter( name )
00053 {
00054 }
00055
00056 CutPlotter::CutPlotter ( const CutPlotter & plotter )
00057 : XyPlotter ( plotter )
00058 {
00059 }
00060
00061 CutPlotter::~CutPlotter ()
00062 {
00063 removeFromTargets ();
00064 }
00065
00070 void
00071 CutPlotter::
00072 setAxisBinding ( const std::vector < std::string > & bindings )
00073 {
00074 DataRep * datarep = selectedDataRep ();
00075 ProjectorBase * pbase = datarep->getProjector ();
00076 NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00077
00078 projector->setAxisBindings ( bindings );
00079
00080 autoScale ();
00081
00082 const vector < TupleCut > & cuts = m_datarep -> getCuts ();
00083 vector < TupleCut > & cut_list
00084 = const_cast < vector < TupleCut > & > ( cuts );
00085
00086 unsigned int size = bindings.size ();
00087 for ( unsigned int i = 0; i < size; i++ ) {
00088 const string & label = bindings[i];
00089 unsigned int index = projector -> indexOf ( label );
00090 TupleCut & cut = cut_list[i];
00091 cut.setColumn ( index );
00092 cut.setLabel ( label );
00093 }
00094
00095 updateTargets();
00096 }
00097
00098 void
00099 CutPlotter::
00100 setCutRangeAt ( const Range & range, unsigned int index )
00101 {
00102 m_datarep -> setCutRangeAt ( range, index );
00103
00104 updateTargets ();
00105 }
00106
00107 void
00108 CutPlotter::
00109 setCutRange ( double low, double high )
00110 {
00111 const Range range ( low, high );
00112 setCutRangeAt ( range, 0 );
00113 }
00114
00115 void
00116 CutPlotter::
00117 removeFromTarget ( DataRep * rep )
00118 {
00119
00120
00121 ProjectorBase * proj = rep->getProjector ();
00122 NTupleProjector * projector =
00123 dynamic_cast < NTupleProjector * > ( proj );
00124 assert( projector );
00125
00126 const vector < TupleCut > & cuts = m_datarep -> getCuts ();
00127 for ( unsigned int i = 0; i < cuts.size(); i++ ) {
00128 projector -> removeCut( & cuts[i] );
00129 }
00130 rep -> removeObserver( this );
00131
00132 TargetList_t::iterator first
00133 = find ( m_targets.begin(), m_targets.end(), rep );
00134 assert ( first != m_targets.end() );
00135 m_targets.erase ( first );
00136
00137 rep -> setDirty();
00138 }
00139
00140 void
00141 CutPlotter::
00142 removeFromTargets()
00143 {
00144 TargetList_t::const_iterator first = m_targets.begin();
00145 while ( first != m_targets.end() ) {
00146 DataRep * rep = *first++;
00147 removeFromTarget ( rep );
00148 }
00149
00150 assert ( m_targets.empty () );
00151 }
00152
00153 void
00154 CutPlotter::
00155 willDelete ( const Observable * obs )
00156 {
00157 const DataRep * rep = dynamic_cast < const DataRep * > ( obs );
00158 assert ( rep );
00159
00160 TargetList_t::iterator first
00161 = find ( m_targets.begin(), m_targets.end(), rep );
00162
00163 if ( first == m_targets.end () ) return;
00164
00165 m_targets.erase ( first );
00166 }
00167
00168 void CutPlotter::updateTargets ()
00169 {
00170 #ifdef BIND2ND_DEFECT
00171 TargetList_t::iterator first = m_targets.begin();
00172 while ( first != m_targets.end() )
00173 {
00174 DataRep * rep = *first++;
00175 rep->setDirty ( true );
00176 }
00177 #else
00178 #ifdef MEMFUN1_DEFECT
00179 for_each ( m_targets.begin(), m_targets.end(),
00180 bind2nd ( mem_fun1 ( &DataRep::setDirty ), true ) );
00181 #else
00182 for_each ( m_targets.begin(), m_targets.end(),
00183 bind2nd ( mem_fun ( &DataRep::setDirty ), true ) );
00184 #endif
00185 #endif
00186 notifyObservers ();
00187 }
00188
00189 const vector < TupleCut > &
00190 CutPlotter::
00191 getCuts () const
00192 {
00193 return m_datarep -> getCuts ();
00194 }
00195
00196 void
00197 CutPlotter::setCuts ( const std::vector < const TupleCut * > & new_cuts )
00198 {
00199 unsigned int size = new_cuts.size ();
00200
00201 if ( m_datarep ) {
00202 const vector < TupleCut > & cuts = m_datarep -> getCuts ();
00203 vector < TupleCut > & cut_list
00204 = const_cast < vector < TupleCut > & > ( cuts );
00205 cut_list.resize ( size, TupleCut () );
00206 for ( unsigned int i = 0; i < cut_list.size (); i++ ) {
00207 cut_list[i] = *new_cuts[i];
00208 }
00209 }
00210 }
00211
00212
00213 bool CutPlotter::hasNTupleBindings () const
00214 {
00215 return true;
00216 }
00217
00218 void CutPlotter::clearCutTargets ()
00219 {
00220 m_targets.clear();
00221 }
00222
00223 void CutPlotter::addCutTarget ( DataRep * rep )
00224 {
00225 if ( rep != m_datarep ) {
00226 m_targets.push_back ( rep );
00227 rep->addObserver ( this );
00228 }
00229 }
00230
00231 const list < DataRep * > & CutPlotter::getCutTargets () const
00232 {
00233 return m_targets;
00234 }
00235
00236 bool CutPlotter::
00237 isTarget ( DataRep * rep ) const
00238 {
00239 return find ( m_targets.begin(), m_targets.end(), rep ) != m_targets.end();
00240 }
00241
00242 void CutPlotter::setCutColor ( const Color & color )
00243 {
00244 RepBase * rep = m_datarep -> getCutRep ();
00245 rep -> setColor ( color );
00246
00247 XyPlotter::update ();
00248
00249 notifyObservers ();
00250 }
00251
00252 const Color & CutPlotter::getCutColor () const
00253 {
00254 RepBase * rep = m_datarep -> getCutRep ();
00255
00256 return rep -> getColor ();
00257 }
00258
00259 void CutPlotter::setNTuple ( const DataSource * ntuple )
00260 {
00261 DataRep * datarep = selectedDataRep ();
00262 ProjectorBase * pbase = datarep->getProjector ();
00263 NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );
00264
00265 projector->setNTuple ( ntuple );
00266 DataSource * nt = const_cast < DataSource * > ( ntuple );
00267 nt->addObserver ( projector );
00268 }
00269
00270 void
00271 CutPlotter::
00272 setEnabled ( bool yes )
00273 {
00274 bool no = false;
00275
00276 const vector < TupleCut > & cuts = m_datarep -> getCuts ();
00277 for ( unsigned int i = 0; i < cuts.size(); i++ ) {
00278 no |= cuts[i].isEnabled ();
00279 m_datarep -> setEnabled ( i, yes );
00280 }
00281
00282 if ( yes != no ) {
00283 updateTargets ();
00284 }
00285 }
00286
00287 void
00288 CutPlotter::
00289 update ( const Observable * object )
00290 {
00291 TargetList_t::const_iterator first
00292 = find ( m_targets.begin(), m_targets.end(), object );
00293
00294 if ( first == m_targets.end () ) {
00295 notifyObservers ();
00296 }
00297 }
00298
00299 void
00300 CutPlotter::
00301 setActive ( bool yes )
00302 {
00303 RepBase * rep = m_datarep -> getCutRep ();
00304 rep -> setSelected ( yes );
00305 notifyObservers ();
00306 }
00307
00308 void
00309 CutPlotter::
00310 addTupleCut ( DataRep * )
00311 {
00312 }
00313
00314 bool
00315 CutPlotter::
00316 isImageConvertable () const
00317 {
00318 return false;
00319 }