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