00001
00012
00013 #ifdef _MSC_VER
00014 #include "msdevstudio/MSconfig.h"
00015 #endif
00016
00017 #include "XmlController.h"
00018
00019 #include "DataRepXML.h"
00020 #include "HiNTupleXML.h"
00021 #include "TupleCutXML.h"
00022 #include "ViewBaseXML.h"
00023 #include "XmlDocument.h"
00024 #include "XmlElement.h"
00025
00026 #include "controllers/CutController.h"
00027 #include "datasrcs/DataSource.h"
00028 #include "datasrcs/DataSourceController.h"
00029 #include "graphics/ViewBase.h"
00030 #include "graphics/ViewFactory.h"
00031
00032 #include <cassert>
00033
00034 using std::map;
00035 using std::list;
00036 using std::string;
00037 using std::vector;
00038
00039 XmlDocument * XmlController::m_xml_doc = 0;
00040
00041 XmlController::XmlController ( )
00042 : m_pasteboard ( 0 ),
00043 m_selectboard ( 0 ),
00044 m_id ( 0 )
00045 {
00046 m_datarep_xml = new DataRepXML ( this );
00047 m_ntuple = new HiNTupleXML ( this );
00048 m_tuple_cut_xml = new TupleCutXML ( this );
00049 m_view = new ViewBaseXML ( this );
00050 }
00051
00052 XmlController::~XmlController ( )
00053 {
00054 delete m_pasteboard;
00055 delete m_view;
00056 }
00057
00058 void
00059 XmlController::
00060 createDocument ( const std::string & doc_name )
00061 {
00062 newDocument ( doc_name );
00063 XmlElement * root = m_xml_doc->createElement ( doc_name );
00064
00065 m_xml_doc->appendChild ( *root );
00066 }
00067
00068 XmlController::Status
00069 XmlController::
00070 openDocument ( const std::string & filename )
00071 {
00072 newDocument ( "HippoDraw" );
00073
00074 XmlDocument::Status rc = m_xml_doc->setContent ( filename );
00075 if ( rc == XmlDocument::OpenError ) return OpenError;
00076 if ( rc == XmlDocument::ParseError ) return ParseError;
00077
00078 return Success;
00079 }
00080
00081 XmlController::Status
00082 XmlController::
00083 openFile ( const std::string & filename )
00084 {
00085 Status status = openDocument ( filename );
00086 if ( status != Success ) return status;
00087
00088 m_views.clear();
00089 m_tuple_map.clear ();
00090 m_tuple_cut_map.clear ();
00091
00092 return openNTuples ();
00093 }
00094
00095 XmlController::Status
00096 XmlController::
00097 openNTuples ( )
00098 {
00099 m_missing_tuples.clear ();
00100
00101 XmlElement * root = m_xml_doc->documentElement ();
00102 list < XmlElement * > nodelist;
00103 m_ntuple->fillNodeList ( root, nodelist );
00104
00105 std::list < XmlElement * >::const_iterator first = nodelist.begin();
00106
00107 while ( first != nodelist.end() ) {
00108 XmlElement * element = *first++;
00109 int id = element->getID ();
00110 const DataSource * ntuple = m_ntuple->getObject ( *element );
00111 if ( ntuple == 0 ) {
00112 const string name = m_ntuple->getName ( *element );
00113 m_missing_tuples.push_back ( name );
00114 }
00115 else {
00116 m_tuple_map[id] = ntuple;
00117 }
00118 }
00119 if ( m_missing_tuples.empty () == true ) return Success;
00120
00121 return NTupleError;
00122 }
00123
00124 bool
00125 XmlController::
00126 isPasteboardEmpty ()
00127 {
00128 return m_pasteboard == 0;
00129 }
00130
00131 const list < ViewBase * > &
00132 XmlController::
00133 getFromPasteboard ( ViewFactory * factory,
00134 const std::vector < const ViewBase * > & views )
00135 {
00136 m_xml_doc = m_pasteboard;
00137
00138 return getFromDocument ( factory, views );
00139 }
00140
00141 const list < ViewBase * > &
00142 XmlController::
00143 getFromSelectionCopy ( ViewFactory * factory,
00144 const std::vector < const ViewBase * > & views )
00145 {
00146 m_xml_doc = m_selectboard;
00147
00148 return getFromDocument ( factory, views );
00149 }
00150
00151 const list < ViewBase * > &
00152 XmlController::
00153 getFromDocument ( ViewFactory * factory,
00154 const std::vector < const ViewBase * > & views )
00155 {
00156 fillNTupleMap ();
00157 fillTupleCutMap ( views );
00158 m_view_factory = factory;
00159
00160 getViews ();
00161
00162 CutController * controller = CutController::instance ();
00163 controller->connectDataRep ( m_views, views );
00164
00165 return m_views;
00166 }
00167
00168 const list < ViewBase * > &
00169 XmlController::getViews ( ViewFactory * factory )
00170 {
00171 m_view_factory = factory;
00172 getViews ();
00173 delete m_xml_doc;
00174
00175 return m_views;
00176 }
00177
00178 bool
00179 XmlController::
00180 areDataSourcesSaved ( const std::vector < const ViewBase * > & views )
00181 {
00182 bool yes = true;
00183 #ifdef ITERATOR_MEMBER_DEFECT
00184 std::
00185 #endif
00186 vector < const ViewBase * > ::const_iterator first = views.begin ();
00187 while ( first != views.end () ) {
00188 const ViewBase * view = *first++;
00189 yes = m_view->areDataSourcesSaved ( *view );
00190 if ( yes == false ) break;
00191 }
00192
00193 return yes;
00194 }
00195
00196 bool
00197 XmlController::
00198 serializeViews ( const std::vector < const ViewBase * > & views )
00199 {
00200 createDocument ( "HippoDraw" );
00201
00202 if ( m_xml_doc == 0 ) return false;
00203
00204 addViews ( views );
00205
00206 return true;
00207 }
00208
00209 void
00210 XmlController::
00211 saveToDocument ( const std::vector < const ViewBase * > & views )
00212 {
00213 m_data.clear ();
00214
00215 serializeViews ( views );
00216 }
00217
00218 void
00219 XmlController::
00220 saveToPasteboard ( const std::vector < const ViewBase * > & selviews )
00221 {
00222 saveToDocument ( selviews );
00223
00224 if ( m_pasteboard != 0 ) delete m_pasteboard;
00225 m_pasteboard = m_xml_doc;
00226 }
00227
00228 void
00229 XmlController::
00230 saveToSelectionCopy ( const std::vector < const ViewBase * > & views )
00231 {
00232 saveToDocument ( views );
00233
00234 if ( m_selectboard != 0 ) delete m_selectboard;
00235 m_selectboard = m_xml_doc;
00236 }
00237
00238 XmlController::Status
00239 XmlController::
00240 saveToFile ( const std::vector < const ViewBase * > & views,
00241 const std::string & filename )
00242 {
00243 m_data.clear();
00244 serializeViews ( views );
00245 XmlDocument::Status status = m_xml_doc->saveToFile ( filename );
00246 delete m_xml_doc;
00247
00248 if ( status != XmlDocument::Success ) return OpenError;
00249
00250 return Success;
00251 }
00252
00253 void
00254 XmlController::
00255 addViews ( const std::vector < const ViewBase * > & views )
00256 {
00257 XmlElement * root = m_xml_doc->documentElement ();
00258
00259 std::vector < const ViewBase * >::const_iterator it = views.begin();
00260 for ( ; it != views.end(); ++it ) {
00261 XmlElement * elem = m_view->createElement ( **it );
00262
00263 root->appendChild ( *elem );
00264 }
00265 }
00266
00267 ViewBase * XmlController::createView ( PlotterBase * plotter )
00268 {
00269 ViewBase * view = m_view_factory->createView ( plotter );
00270 m_views.push_back ( view );
00271
00272 return view;
00273 }
00274
00275 FontBase *
00276 XmlController::
00277 createFont () const
00278 {
00279 return m_view_factory -> createFont ();
00280 }
00281
00282 XmlElement * XmlController::addDataSource ( const DataSource * ntuple )
00283 {
00284 std::map < const DataSource *, XmlElement * >::const_iterator it
00285 = m_data.find ( ntuple );
00286 if ( it != m_data.end () ) {
00287 return it->second;
00288 }
00289 XmlElement * element = m_ntuple->createElement ( *ntuple );
00290
00291 m_data[ntuple] = element;
00292
00293 XmlElement * root = m_xml_doc->documentElement ();
00294 root->appendChild ( *element );
00295
00296 return element;
00297 }
00298
00299 const DataSource * XmlController::getDataSource ( int ref )
00300 {
00301 std::map < int, const DataSource * >::const_iterator it
00302 = m_tuple_map.find ( ref );
00303 if ( it == m_tuple_map.end () ) {
00304 return 0;
00305 }
00306
00307 return it->second;
00308 }
00309
00310 const TupleCut * XmlController::getTupleCut ( int ref )
00311 {
00312 const TupleCut * cut = 0;
00313
00314 std::map < int, const TupleCut * >::iterator it
00315 = m_tuple_cut_map.find ( ref );
00316 if ( it == m_tuple_cut_map.end() &&
00317 ref >=0 ) {
00318 it = m_tuple_cut_map.find ( -ref );
00319 }
00320 if ( it != m_tuple_cut_map.end() ) {
00321 cut = it->second;
00322 }
00323
00324 return cut;
00325 }
00326
00327 DataRep * XmlController::getDataRep ( int ref )
00328 {
00329 std::map < int, DataRep * >::iterator it
00330 = m_datarep_map.find ( ref );
00331
00332 if ( it == m_datarep_map.end() ) return 0;
00333
00334 return it->second;
00335 }
00336
00337 PlotterBase *
00338 XmlController::
00339 getPlotter ( int ref )
00340 {
00341 std::map < int, PlotterBase * >::iterator it
00342 = m_plotter_map.find ( ref );
00343
00344 if ( it == m_plotter_map.end() ) return 0;
00345
00346 return it->second;
00347 }
00348
00349 void
00350 XmlController::
00351 registerPlotter ( int id, PlotterBase * plotter )
00352 {
00353 m_plotter_map [ id ] = plotter;
00354 }
00355
00356 void
00357 XmlController::
00358 fillNTupleMap ()
00359 {
00360 m_tuple_map.clear();
00361 DataSourceController * controller = DataSourceController::instance ();
00362 const vector < DataSource * > & tuples = controller->getDataSources ();
00363 #ifdef ITERATOR_MEMBER_DEFECT
00364 std::
00365 #endif
00366 vector < DataSource * > ::const_iterator first = tuples.begin();
00367 for ( ; first != tuples.end(); ++first ) {
00368 const void * addr = reinterpret_cast < const void * > ( *first );
00369 int ref = getId ( addr );
00370 m_tuple_map[ref] = *first;
00371 }
00372 }
00373
00374 void XmlController::
00375 fillTupleCutMap ( const std::vector < const ViewBase * > & views )
00376 {
00377 m_tuple_cut_map.clear();
00378 vector < const TupleCut * > cut_list;
00379 CutController * controller = CutController::instance ();
00380
00381 controller->fillTupleCutList ( views, cut_list );
00382
00383 vector < const TupleCut * > :: iterator first = cut_list.begin ();
00384 while ( first != cut_list.end () ) {
00385 const TupleCut * cut = *first++;
00386 void * addr = reinterpret_cast < void * > ( &cut );
00387 int id = getId ( addr );
00388 m_tuple_cut_map [ id ] = cut;
00389 }
00390 }
00391
00392 void XmlController::getDataReps ()
00393 {
00394 XmlElement * root = m_xml_doc->documentElement ();
00395 list < XmlElement * > nodelist;
00396 m_datarep_xml->fillNodeList ( root, nodelist );
00397
00398 #ifdef ITERATOR_MEMBER_DEFECT
00399 std::
00400 #endif
00401 list < XmlElement * > ::const_iterator first = nodelist.begin();
00402
00403 for ( ; first != nodelist.end(); ++first ) {
00404
00405 XmlElement * element = *first;
00406 int id = element->getID ();
00407 DataRep * rep = m_datarep_xml->createObject ( element );
00408 m_datarep_map[id] = rep;
00409
00410 }
00411
00412 }
00413
00414 void XmlController::getTupleCuts ()
00415 {
00416 XmlElement * root = m_xml_doc->documentElement ();
00417 list < XmlElement * > nodelist;
00418 m_tuple_cut_xml->fillNodeList ( root, nodelist );
00419
00420
00421 std::list < XmlElement * >::const_iterator first = nodelist.begin();
00422
00423 for ( ; first != nodelist.end(); ++first ) {
00424 XmlElement * element = *first;
00425 if ( m_tuple_cut_xml -> hasMultiDimTupleCut ( element ) ) {
00426 vector < TupleCut * > cuts;
00427 m_tuple_cut_xml -> getObjects ( element, cuts );
00428 for ( unsigned int i = 0; i < cuts.size (); i++ ) {
00429 int id = element -> getID ();
00430 if ( i == 1 ) id = -id;
00431 m_tuple_cut_map[id] = cuts[i];
00432 }
00433 }
00434 else {
00435 TupleCut * cut = m_tuple_cut_xml->getObject ( *element );
00436 int id = element->getID ();
00437 m_tuple_cut_map[id] = cut;
00438 }
00439 }
00440 }
00441
00442 void XmlController::getViews ( )
00443 {
00444 m_views.clear();
00445 if ( m_xml_doc != 0 ) {
00446 getTupleCuts ();
00447 getDataReps ();
00448
00449 XmlElement * root = m_xml_doc->documentElement ();
00450 list < XmlElement * > nodelist;
00451 m_view->fillNodeList ( root, nodelist );
00452
00453 if ( nodelist.empty () ) return;
00454
00455
00456 std::list < XmlElement * >::const_iterator first = nodelist.begin ();
00457 for ( ; first != nodelist.end(); ++ first ) {
00458 m_view->getObjects ( *first );
00459 }
00460
00461 m_view -> connectPlotters ( root );
00462 }
00463 }
00464
00465 int
00466 XmlController::
00467 getId ( const void * addr )
00468 {
00469 int id = 0;
00470 AddrMapIterator_t it = m_addr_map.find ( addr );
00471 if ( it == m_addr_map.end () ) {
00472 id = m_id;
00473 m_addr_map [ addr ] = m_id++;
00474 }
00475 else {
00476 id = it -> second;
00477 }
00478
00479 return id;
00480 }