CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
FWGeometryTableManager.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: Core
4 // Class : FWGeometryTableManager
5 //
6 // Implementation:
7 // [Notes on implementation]
8 //
9 // Original Author: Alja Mrak-Tadel, Matevz Tadel
10 // Created: Thu Jan 27 14:50:57 CET 2011
11 // $Id: FWGeometryTableManager.cc,v 1.40 2011/07/20 23:18:59 amraktad Exp $
12 //
13 
14 //#define PERFTOOL_GEO_TABLE
15 
16 // user include files
17 #include <iostream>
18 #include <boost/bind.hpp>
19 #include <stack>
20 #ifdef PERFTOOL_GEO_TABLE
21 #include <google/profiler.h>
22 #endif
30 
31 #include "TMath.h"
32 #include "TGeoVolume.h"
33 #include "TGeoMatrix.h"
34 #include "TGeoShape.h"
35 #include "TGeoBBox.h"
36 #include "TGeoMatrix.h"
37 #include "TEveUtil.h"
38 
39 #include "TGFrame.h"
40 
41 static const char* redTxt = "\033[01;31m";
42 //static const char* greenTxt = "\033[01;32m";
43 // static const char* cyanTxt = "\033[22;36m";
44 // static const char* whiteTxt = "\033[0m";
45 
47 {
48  return m_node->GetName();
49 }
50 
52 {
53  std::string x(m_level*3 , ' ');
54  x += m_node->GetName();
55  return x.c_str();
56 }
57 
60  m_width(1),
61  m_height(1),
62  m_color(0xffffff),
63  m_isSelected(false)
64 {
65  GCValues_t gval;
66  gval.fMask = kGCForeground | kGCBackground | kGCStipple | kGCFillStyle | kGCGraphicsExposures;
67  gval.fStipple = gClient->GetResourcePool()->GetCheckeredBitmap();
68  gval.fGraphicsExposures = kFALSE;
69  gval.fBackground = gVirtualX->GetPixel(kGray);
70  m_colorContext = gClient->GetResourcePool()->GetGCPool()->GetGC(&gval,kTRUE);
71 
72 }
73 
75 {
76  gClient->GetResourcePool()->GetGCPool()->FreeGC(m_colorContext->GetGC());
77 }
78 
80 {
81  m_color = gVirtualX->GetPixel(c);
82  m_isSelected = s;
83 }
84 
85 
86 void FWGeometryTableManager::ColorBoxRenderer::draw(Drawable_t iID, int iX, int iY, unsigned int iWidth, unsigned int iHeight)
87 {
90  iWidth += 2*FWTabularWidget::kTextBuffer;
91  iHeight += 2*FWTabularWidget::kTextBuffer;
92 
93  m_colorContext->SetFillStyle(kFillSolid);
94  Pixel_t baq = m_colorContext->GetForeground();
95  m_colorContext->SetForeground(m_color);
96  gVirtualX->FillRectangle(iID, m_colorContext->GetGC(), iX, iY, iWidth, iHeight);
97 
98  if (m_isSelected)
99  {
100  m_colorContext->SetFillStyle(kFillOpaqueStippled);
101  gVirtualX->FillRectangle(iID, m_colorContext->GetGC(), iX, iY, iWidth, iHeight);
102  }
103  m_colorContext->SetForeground(baq);
104 }
105 
106 //==============================================================================
107 //==============================================================================
108 //
109 // class FWGeometryTableManager
110 //
111 //==============================================================================
112 //==============================================================================
113 
115 : m_selectedRow(-1),
116  m_selectedIdx(0),
117  m_selectedColumn(-1),
118  m_browser(browser),
119  m_filterOff(true),
121  m_levelOffset(0)
122 {
125 }
126 
128 {
129 }
130 
131 
133 {
134  return unsorted;
135 }
136 
138 {
139  return m_row_to_index.size();
140 }
141 
143 {
144  return kNumCol;
145 }
146 
147 
148 std::vector<std::string> FWGeometryTableManager::getTitles() const
149 {
150  std::vector<std::string> returnValue;
151  returnValue.reserve(numberOfColumns());
152 
153  if (m_browser->getVolumeMode() )
154  returnValue.push_back("Volume Name");
155  else
156  returnValue.push_back("Node Name");
157 
158  returnValue.push_back("Color");
159  returnValue.push_back("RnrSelf");
160  returnValue.push_back("RnrChildren");
161  returnValue.push_back("Material");
162  returnValue.push_back("X");
163  returnValue.push_back("Y");
164  returnValue.push_back("Z");
165  // returnValue.push_back("Diagonal");
166 
167  return returnValue;
168 }
169 
170 void FWGeometryTableManager::setSelection (int row, int column, int mask)
171 {
172  changeSelection(row, column);
173 }
174 
175 const std::string FWGeometryTableManager::title() const
176 {
177  return "Geometry";
178 }
179 
181 {
182  return m_selectedRow;
183 }
184 
186 {
187  return m_selectedColumn;
188 }
189 
191 {
192  return m_selectedRow == row;
193 }
194 
195 void FWGeometryTableManager::changeSelection(int iRow, int iColumn)
196 {
197  if (iRow < 0) return;
198 
199  m_selectedRow = iRow;
200  m_selectedColumn = iColumn;
201  if (m_row_to_index.size() > 0) m_selectedIdx = m_row_to_index[iRow];
202 
203  // printf("WGeometryTableManager::changeSelecti row %d index %d \n", m_selectedIdx, m_selectedIdx );
205 }
206 
208 {
209  if(iToWhite) {
210  m_renderer.setGraphicsContext(&TGFrame::GetBlackGC());
212  } else {
213  static const TGGC* s_blackHighLight = 0;
214  if (!s_blackHighLight) {
215  GCValues_t gval;
216  gval.fMask = kGCForeground | kGCBackground | kGCStipple | kGCFillStyle | kGCGraphicsExposures;
217  gval.fForeground = 0xbbbbbb;
218  gval.fBackground = 0x000000;
219  gval.fFillStyle = kFillOpaqueStippled;
220  gval.fStipple = gClient->GetResourcePool()->GetCheckeredBitmap();
221  gval.fGraphicsExposures = kFALSE;
222  s_blackHighLight = gClient->GetGC(&gval, kTRUE);
223  }
224  m_renderer.setHighlightContext(s_blackHighLight);
225  m_renderer.setGraphicsContext(&TGFrame::GetWhiteGC());
226  }
227  m_renderer.setBlackIcon(iToWhite);
228 }
229 
230 //______________________________________________________________________________
231 
232 FWTableCellRendererBase* FWGeometryTableManager::cellRenderer(int iSortedRowNumber, int iCol) const
233 {
234  struct Cache
235  {
236  TGeoHMatrix mtx;
237  double pos[3];
238  int row;
239 
240  };
241 
242  static Cache mxCache;
243  if (static_cast<int>(m_row_to_index.size()) <= iSortedRowNumber)
244  {
245  m_renderer.setData(std::string("FWGeometryTableManager::cellRenderer() Error!"), false);
246  return &m_renderer;
247  }
248 
249  static char sval[12];
250  static std::string zero = "0.000";
251 
252  FWTextTreeCellRenderer* renderer = &m_renderer;
253 
254  int unsortedRow = m_row_to_index[iSortedRowNumber];
255  const NodeInfo& data = m_entries[unsortedRow];
256  TGeoNode& gn = *data.m_node;
257 
258  bool isSelected = (iCol == kMaterial ) && (!m_filterOff && m_volumes[gn.GetVolume()].m_matches);//(m_selectedRow == unsortedRow);
259 
260  if (iCol == kName)
261  {
262  //int nD = getNdaughtersLimited(data.m_node);
263  int nD = data.m_node->GetNdaughters();
264  if (m_browser->getVolumeMode())
265  renderer->setData(Form("%s [%d]", gn.GetVolume()->GetName(), nD), isSelected);
266  else
267  renderer->setData(Form("%s [%d]", gn.GetName(), nD), isSelected);
268 
269  renderer->setIsParent((gn.GetNdaughters() > 0) && (m_filterOff || data.testBit(kChildMatches) ));
270 
272 
273  int level = data.m_level - m_levelOffset;
274 
275  if (data.m_node->GetNdaughters())
276  renderer->setIndentation(20*level);
277  else
278  renderer->setIndentation(20*level + FWTextTreeCellRenderer::iconWidth());
279 
280  return renderer;
281  }
282  else
283  {
284  // printf("title %s \n",data.m_node->GetTitle() );
285  renderer->setIsParent(false);
286  renderer->setIndentation(0);
287  if (iCol == kColor)
288  {
289  // m_colorBoxRenderer.setData(data.m_node->GetVolume()->GetLineColor(), isSelected);
290  m_colorBoxRenderer.setData(data.m_color, isSelected);
291  return &m_colorBoxRenderer;
292  }
293  else if (iCol == kVisSelf )
294  {
295  renderer->setData(getVisibility(data) ? "On" : "-", isSelected );
296  return renderer;
297  }
298  else if (iCol == kVisChild )
299  {
300  renderer->setData( getVisibilityChld(data) ? "On" : "-", isSelected);
301  return renderer;
302  }
303  else if (iCol == kMaterial )
304  {
305  renderer->setData( gn.GetVolume()->GetMaterial()->GetName(), isSelected);
306  return renderer;
307  }
308 
309  else if (iCol == kPosX || iCol == kPosY || iCol == kPosZ)
310  {
311  if (mxCache.row != iSortedRowNumber) {
312  mxCache.row = iSortedRowNumber;
313  mxCache.pos[0] = 0; mxCache.pos[1] = 0; mxCache.pos[2] = 0;
314  mxCache.mtx.Clear();
315  getNodeMatrix(data, mxCache.mtx);
316  TGeoBBox* bb = static_cast<TGeoBBox*>(data.m_node->GetVolume()->GetShape());
317  const double* origin = bb->GetOrigin();
318  mxCache.mtx.LocalToMaster(origin, mxCache.pos);
319  }
320  float val = mxCache.pos[iCol - kPosX];
321  if (val < 0.001) {
322  renderer->setData(zero, isSelected);
323  }
324  else {
325  snprintf(sval, sizeof(sval), "%.3f", val);
326  renderer->setData(sval, isSelected);
327 
328  }
329 
330  return renderer;
331  }
332  else
333  {
334  TGeoBBox* gs = static_cast<TGeoBBox*>( gn.GetVolume()->GetShape());
335  float val = TMath::Sqrt(gs->GetDX()*gs->GetDX() + gs->GetDY()*gs->GetDY() +gs->GetDZ()*gs->GetDZ() );
336  // renderer->setData( Form("%.3f", TMath::Sqrt(gs->GetDX()*gs->GetDX() + gs->GetDY()*gs->GetDY() +gs->GetDZ()*gs->GetDZ() )), isSelected);
337  if (val < 0.001) {
338  renderer->setData(zero, isSelected);
339  }
340  else {
341  snprintf(sval, sizeof(sval), "%.3f", val);
342  renderer->setData(sval, isSelected);
343  }
344  return renderer;
345  }
346 
347  }
348 }
349 
350 //______________________________________________________________________________
352 {
353  if (row == -1)
354  return;
355 
356  int idx = rowToIndex()[row];
357  // printf("click %s \n", m_entries[idx].name());
358 
359  m_entries[idx].switchBit(kExpanded);
360 
362  dataChanged();
364 }
365 
366 //______________________________________________________________________________
368 {
369  if (!data.testBit(kFilterCached))
370  {
371  bool matches = m_volumes[data.m_node->GetVolume()].m_matches;
372  data.setBitVal(kMatches, matches);
373  setVisibility(data, matches);
374 
375  bool childMatches = m_volumes[data.m_node->GetVolume()].m_childMatches;
376  data.setBitVal(kChildMatches, childMatches);
377  data.setBitVal(kExpanded, childMatches);
378  setVisibilityChld(data, childMatches);
379 
380 
381  data.setBit(kFilterCached);
382  // printf("%s matches [%d] childMatches [%d] ................ %d %d \n", data.name(), data.testBit(kMatches), data.testBit(kChildMatches), matches , childMatches);
383  }
384 }
385 
386 //______________________________________________________________________________
387 
389 {
390  m_row_to_index.clear();
391  int i = TMath::Max(0, m_browser->getTopNodeIdx());
392  m_row_to_index.push_back(i);
393 
394  NodeInfo& data = m_entries[i];
395  if (!m_filterOff)
396  assertNodeFilterCache(data);
397 
398  if ((m_filterOff && data.testBit(kExpanded) == false) ||
399  (m_filterOff == false && data.testBit(kChildMatches) == false) )
400  return;
401 
402 
403  if (m_browser->getVolumeMode())
405  else
407 
408  // printf (" child [%d] FWGeometryTableManager::recalculateVisibility table size %d \n", (int)m_row_to_index.size());
409 }
410 
411 
413 {
414  TGeoNode* parentNode = m_entries[pIdx].m_node;
415  int nD = parentNode->GetNdaughters();
416  int dOff=0;
417  for (int n = 0; n != nD; ++n)
418  {
419  int idx = pIdx + 1 + n + dOff;
420  NodeInfo& data = m_entries[idx];
421 
422  if (m_filterOff)
423  {
424  m_row_to_index.push_back(idx);
426  }
427  else
428  {
429  assertNodeFilterCache(data);
430  if (data.testBitAny(kMatches | kChildMatches)) m_row_to_index.push_back(idx);
432  }
433 
434  FWGeometryTableManager::getNNodesTotal(parentNode->GetDaughter(n), dOff);
435  }
436 }
437 
438 //______________________________________________________________________________
439 
441 {
442  TGeoNode* parentNode = m_entries[pIdx].m_node;
443  int nD = parentNode->GetNdaughters();
444  int dOff=0;
445 
446  // printf("----------- parent %s\n", parentNode->GetName() );
447 
448  std::vector<int> vi;
449  vi.reserve(nD);
450 
451 
452  for (int n = 0; n != nD; ++n)
453  {
454  int idx = pIdx + 1 + n + dOff;
455  NodeInfo& data = m_entries[idx];
456 
457  bool toAdd = true;
458  for (std::vector<int>::iterator u = vi.begin(); u != vi.end(); ++u )
459  {
460  TGeoVolume* neighbourVolume = parentNode->GetDaughter(*u)->GetVolume();
461  if (neighbourVolume == data.m_node->GetVolume())
462  {
463  toAdd = false;
464  // printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
465  break;
466  }
467  }
468 
469  if (toAdd)
470  {
471  vi.push_back(n);
472  if (m_filterOff)
473  {
474  // std::cout << data.nameIndent() << std::endl;
475  m_row_to_index.push_back(idx);
477  }
478  else
479  {
480  assertNodeFilterCache(data);
481  if (data.testBitAny(kMatches | kChildMatches)) m_row_to_index.push_back(idx);
483  }
484  }
485  FWGeometryTableManager::getNNodesTotal(parentNode->GetDaughter(n), dOff);
486  }
487 }
488 
489 
490 //______________________________________________________________________________
491 
493 {
494  if (m_entries.empty()) return;
495 
496  changeSelection(0, 0);
497 
499 
500  // if (m_filterOff)
501  // m_statusMessage = Form("level:%d rows %d ", getLevelOffset(), (int)m_row_to_index.size());
502  // else
503  // m_statusMessage = Form("level:%d rows %d volumes %d (%.2f %%) selected ", getLevelOffset(), (int)m_row_to_index.size(), m_numVolumesMatched, 100.0* m_numVolumesMatched/m_volumes.size());
504 
505  dataChanged();
507 }
508 
509 //==============================================================================
510 
511 void FWGeometryTableManager::loadGeometry( TGeoNode* iGeoTopNode, TObjArray* iVolumes)
512 {
513 #ifdef PERFTOOL_GEO_TABLE
514  ProfilerStart("loadGeo");
515 #endif
516 
517  // Prepare data for cell render.
518 
519  // clear entries
520  m_entries.clear();
521  m_row_to_index.clear();
522  m_volumes.clear();
523  m_levelOffset = 0;
524 
525  // set volume table for filters
526  boost::unordered_map<TGeoVolume*, Match> pipi(iVolumes->GetSize());
527  m_volumes.swap(pipi);
528  TIter next( iVolumes);
529  TGeoVolume* v;
530  while ((v = (TGeoVolume*) next()) != 0)
531  m_volumes.insert(std::make_pair(v, Match()));
532 
533  if (!m_filterOff)
534  updateFilter();
535 
536  // add top node to init
537 
538  int nTotal = 0;
539  NodeInfo topNodeInfo;
540  topNodeInfo.m_node = iGeoTopNode;
541  topNodeInfo.m_level = 0;
542  topNodeInfo.m_parent = -1;
543  if (m_browser->getAutoExpand())
544  topNodeInfo.setBit(kExpanded);
545 
546  getNNodesTotal(topNodeInfo.m_node , nTotal);
547  m_entries.resize(nTotal+1);
548  m_entries[0] = topNodeInfo;
549 
550  importChildren(0);
551 
552  // checkHierarchy();
553 
554 #ifdef PERFTOOL_GEO_TABLE
555  ProfilerStop();
556 #endif
557 }
558 
559 //==============================================================================
560 
561 
562 //______________________________________________________________________________
563 
565 {
566  NodeInfo& parent = m_entries[parent_idx];
567  TGeoNode* parentGeoNode = parent.m_node;
568  int parentLevel = parent.m_level;
569 
570  int nV = parentGeoNode->GetNdaughters();
571  int dOff = 0;
572  for (int n = 0; n != nV; ++n)
573  {
574  NodeInfo& data = m_entries[parent_idx + n + 1 + dOff];
575  data.m_node = parentGeoNode->GetDaughter(n);
576  data.m_level = parentLevel + 1;
577  data.m_parent = parent_idx;
578  data.m_color = data.m_node->GetVolume()->GetLineColor();
579  if (data.m_level <= m_browser->getAutoExpand()) data.setBit(kExpanded);
580 
581 
582  importChildren(parent_idx + n + 1 + dOff);
583  getNNodesTotal(parentGeoNode->GetDaughter(n), dOff);
584  }
585 }
586 
587 //==============================================================================
588 
590 {
591  // Used for debug: in a NodeInfo entry look TGeoNode children from parent index and check
592  // if child is found.
593 
594  for ( size_t i = 0, e = m_entries.size(); i != e; ++i )
595  {
596  if ( m_entries[i].m_level > 0)
597  {
598  TGeoNode* pn = m_entries[m_entries[i].m_parent].m_node;
599  bool ok = false;
600  for (int d = 0; d < pn->GetNdaughters(); ++d )
601  {
602  if (m_entries[i].m_node == pn->GetDaughter(d))
603  {
604  ok = true;
605  break;
606  }
607  }
608  if (!ok) printf("%s!!!!!! node %s has false parent %s \n", redTxt, m_entries[i].name(), pn->GetName());
609  }
610  }
611 }
612 
613 void FWGeometryTableManager::checkChildMatches(TGeoVolume* vol, std::vector<TGeoVolume*>& pstack)
614 {
615  if (m_volumes[vol].m_matches)
616  {
617  for (std::vector<TGeoVolume*>::iterator i = pstack.begin(); i!= pstack.end(); ++i)
618  {
619  Match& pm = m_volumes[*i];
620  pm.m_childMatches = true;
621  }
622  }
623 
624  pstack.push_back(vol);
625 
626  int nD = vol->GetNdaughters();//TMath::Min(m_browser->getMaxDaughters(), vol->GetNdaughters());
627  for (int i = 0; i!=nD; ++i)
628  checkChildMatches(vol->GetNode(i)->GetVolume(), pstack);
629 
630  pstack.pop_back();
631 }
632 
633 // callbacks ______________________________________________________________________________
634 
636 {
637  std::string filterExp = m_browser->getFilter();
638  m_filterOff = filterExp.empty();
639  // printf("update filter %s OFF %d volumes size %d\n",filterExp.c_str(), m_filterOff , (int)m_volumes.size());
640 
641  if (m_filterOff || m_entries.empty()) return;
642 
643  // update volume-match entries
645  for (Volumes_i i = m_volumes.begin(); i!= m_volumes.end(); ++i)
646  {
647  if (strcasestr(i->first->GetMaterial()->GetName(), filterExp.c_str()) > 0) {
648  i->second.m_matches = true;
650  }
651  else {
652  i->second.m_matches = false;
653  }
654  i->second.m_childMatches = false;
655  }
656 
657  std::vector<TGeoVolume*> pstack;
658  checkChildMatches(m_entries[TMath::Max(0,m_browser->getTopNodeIdx())].m_node->GetVolume(), pstack);
659 
660 
661  for (Entries_i ni = m_entries.begin(); ni != m_entries.end(); ++ni)
662  ni->resetBit(kFilterCached);
663 
664 }
665 
666 
668 {
669  Entries_i i = m_entries.begin();
670  std::advance(i,m_selectedIdx );
671  return i; //m_entries[m_selectedIdx];
672 }
673 
674 void FWGeometryTableManager::getNodePath(int idx, std::string& path) const
675 {
676  std::vector<std::string> relPath;
677  while(idx >= 0)
678  {
679  relPath.push_back( m_entries[idx].name());
680  // printf("push %s \n",m_entries[idx].name() );
681  idx = m_entries[idx].m_parent;
682  }
683 
684  size_t ns = relPath.size();
685  for (size_t i = 1; i < ns; ++i )
686  {
687  path +="/";
688  path += relPath[ns-i -1];
689  // printf("push_back add to path %s\n", path.c_str());
690  }
691 }
692 
693 //______________________________________________________________________________
694 
696 {
697  // check expand state
698  int ae = m_browser->getAutoExpand() + m_levelOffset;
699  for (Entries_i i = m_entries.begin(); i != m_entries.end(); ++i)
700  {
701  if (i->m_level < ae)
702  i->setBit(kExpanded);
703  else
704  i->resetBit(kExpanded);
705  }
706 }
707 
708 //______________________________________________________________________________
709 
710 
712 {
713  // cached
714  if (idx >= 0)
715  m_levelOffset = m_entries[idx].m_level;
716  else
717  m_levelOffset = 0;
718 
719 }
720 
722 {
723  // static double pnt[3];
724  std::string path;
725  getNodePath(idx, path);
726  printf("My %s parent %s path %d \n",m_entries[idx].name(),path.c_str(), m_entries[idx].m_parent );
727  /*
728  for (int i =0, k = m_entries.size(); i < k; ++i)
729  {
730  const NodeInfo& ni = m_entries[i];
731  if (ni.m_parent == idx)
732  {
733  std::string indent(ni.m_level*3 , ' ');
734 
735  // printf("%s%s (%.2f, %.2f, %.2f)\n",indent.c_str(), ni.name(), pnt[0], pnt[1], pnt[2]);
736  printf("%s%s \n",indent.c_str(), ni.name());
737 
738  printChildren(i);
739  }
740  }*/
741 }
742 
744 {
745  int dOff = 0;
746  TGeoNode* parentNode = m_entries[m_selectedIdx].m_node;
747  int nD = parentNode->GetNdaughters();
748  for (int n = 0; n != nD; ++n)
749  {
750  int idx = m_selectedIdx + 1 + n + dOff;
751  NodeInfo& data = m_entries[idx];
752 
753  setVisibility(data, v);
754  setVisibilityChld(data, v);
755 
756  FWGeometryTableManager::getNNodesTotal(parentNode->GetDaughter(n), dOff);
757  }
758 }
759 
760 //______________________________________________________________________________
761 void FWGeometryTableManager::getNodeMatrix(const NodeInfo& data, TGeoHMatrix& mtx) const
762 {
763  // utility used by browser and FWGeoNode
764 
765  int pIdx = data.m_parent;
766  int endl = data.m_level -1;
767  for (int l = 0 ; l < endl ; ++l)
768  {
769  pIdx = m_entries.at(pIdx).m_parent;
770  mtx.MultiplyLeft(m_entries.at(pIdx).m_node->GetMatrix());
771  }
772 
773  mtx.Multiply(data.m_node->GetMatrix());
774 }
775 //==============================================================================
776 
778 {
779  if (m_browser->getVolumeMode())
780  {
781  if (data.m_node->GetVolume()->IsVisible() != x)
782  {
783  TEveGeoManagerHolder gmgr( FWGeometryTableViewManager::getGeoMangeur());
784  data.m_node->GetVolume()->SetVisibility(x);
785  }
786  }
787  else
788  {
789  data.setBitVal(kVisNode, x);
790  }
791 }
792 
794 {
795  if (m_browser->getVolumeMode())
796  {
797  if (data.m_node->GetVolume()->IsVisibleDaughters() != x)
798  {
799  TEveGeoManagerHolder gmgr( FWGeometryTableViewManager::getGeoMangeur());
800  data.m_node->GetVolume()->VisibleDaughters(x);
801  }
802  }
803  else
804  {
805  data.setBitVal(kVisNodeChld, x);
806  }
807 }
808 
809 //______________________________________________________________________________
810 
812 {
813  if (m_browser->getVolumeMode())
814  return data.m_node->GetVolume()->IsVisible();
815  else
816  return data.testBit(kVisNode);
817 
818 }
819 
821 {
822  if (m_browser->getVolumeMode())
823  return data.m_node->GetVolume()->IsVisibleDaughters();
824  else
825  return data.testBit(kVisNodeChld);
826 
827 }
828 //==============================================================================
829 
830 //______________________________________________________________________________
831 
833 {
834  std::map<TGeoMaterial*, std::string> mlist;
835  Entries_i it = m_entries.begin();
836  std::advance(it, m_selectedIdx );
837  int nLevel = it->m_level;
838  it++;
839  while (it->m_level > nLevel)
840  {
841  TGeoMaterial* m = it->m_node->GetVolume()->GetMaterial();
842  if (mlist.find(m) == mlist.end())
843  {
844  mlist[m] = m->GetName();
845  }
846  it++;
847  }
848 
849  printf("size %d \n", (int)mlist.size());
850  for(std::map<TGeoMaterial*, std::string>::iterator i = mlist.begin(); i != mlist.end(); ++i)
851  {
852  printf("material %s \n", i->second.c_str());
853  }
854 
855 }
856 
void setVisibility(NodeInfo &nodeInfo, bool)
FWGeometryTableView * m_browser
void loadGeometry(TGeoNode *, TObjArray *)
virtual UInt_t height() const
returns the minimum height of the cell to which the renderer is representing
int i
Definition: DBlmapReader.cc:9
virtual int unsortedRowNumber(int unsorted) const
when passed the index to the sorted order of the rows it returns the original row number from the und...
virtual std::vector< std::string > getTitles() const
returns the title names for each column
list parent
Definition: dbtoconf.py:74
bool getVisibilityChld(const NodeInfo &nodeInfo) const
virtual FWTableCellRendererBase * cellRenderer(int iSortedRowNumber, int iCol) const
FWGeometryTableManager(FWGeometryTableView *)
FWTextTreeCellRenderer m_renderer
void setVisibilityChld(NodeInfo &nodeInfo, bool)
void getNodePath(int, std::string &) const
std::string getFilter() const
void dataChanged()
Classes which inherit from FWTableManagerBase must call this when their underlying data changes...
int path() const
Definition: HLTadd.h:3
virtual bool rowIsSelected(int row) const
std::vector< int > rowToIndex()
ColorBoxRenderer m_colorBoxRenderer
std::vector< int > m_row_to_index
void setHighlightContext(const TGGC *context)
virtual const std::string title() const
bool getVisibility(const NodeInfo &nodeInfo) const
static TGeoManager * getGeoMangeur()
static const TGGC & getDefaultHighlightGC()
virtual void draw(Drawable_t iID, int iX, int iY, unsigned int iWidth, unsigned int iHeight)
void assertNodeFilterCache(NodeInfo &data)
void setGraphicsContext(const TGGC *iContext)
static const char * redTxt
virtual void setIndentation(int indentation=0)
void setSelection(int row, int column, int mask)
void setData(const std::string &, bool isSelected)
void getNodeMatrix(const NodeInfo &nodeInfo, TGeoHMatrix &mat) const
static void getNNodesTotal(TGeoNode *geoNode, int &off)
Entries_v::iterator Entries_i
void checkChildMatches(TGeoVolume *v, std::vector< TGeoVolume * > &)
bool getVolumeMode() const
virtual int numberOfColumns() const
Number of columns in the table.
void visualPropertiesChanged()
Classes which inherit from FWTableManagerBase must call this when how the data is shown (e...
Volumes_t::iterator Volumes_i
static const int kTextBuffer
tuple level
Definition: testEve_cfg.py:34
string s
Definition: asciidump.py:422
Definition: DDAxes.h:10
void importChildren(int parent_idx)
virtual int numberOfRows() const
Number of rows in the table.
mathSSE::Vec4< T > v
void changeSelection(int iRow, int iColumn)