FWSimpleProxyBuilder.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Core
// Class  :     FWGlimpseSimpleProxyBuilder
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones, Alja Mrak-Tadel
//         Created:  Tue March 28 09:46:41 EST 2010
//
 
// system include files
#include <memory>
 
// user include files
#include "TEveCompound.h"
#include "Fireworks/Core/interface/FWSimpleProxyBuilder.h"
#include "Fireworks/Core/interface/FWEventItem.h"
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
 
//
// constructors and destructor
//
FWSimpleProxyBuilder::FWSimpleProxyBuilder(const std::type_info& iType) : m_helper(iType) {}
 
// FWSimpleProxyBuilder::FWSimpleProxyBuilder(const FWSimpleProxyBuilder& rhs)
// {
//    // do actual copying here;
// }
 
FWSimpleProxyBuilder::~FWSimpleProxyBuilder() {}
 
//
// assignment operators
//
// const FWSimpleProxyBuilder& FWSimpleProxyBuilder::operator=(const FWSimpleProxyBuilder& rhs)
// {
//   //An exception safe implementation is
//   FWSimpleProxyBuilder temp(rhs);
//   swap(rhs);
//
//   return *this;
// }
 
//
// member functions
//
 
void FWSimpleProxyBuilder::clean() {
  for (Product_it i = m_products.begin(); i != m_products.end(); ++i) {
    if ((*i)->m_elements) {
      TEveElement* elms = (*i)->m_elements;
      for (TEveElement::List_i it = elms->BeginChildren(); it != elms->EndChildren(); ++it)
        (*it)->DestroyElements();
    }
  }
 
  cleanLocal();
}
 
void FWSimpleProxyBuilder::itemChangedImp(const FWEventItem* iItem) {
  if (iItem) {
    m_helper.itemChanged(iItem);
  }
}
 
void FWSimpleProxyBuilder::build(const FWEventItem* iItem, TEveElementList* product, const FWViewContext* vc) {
  size_t size = iItem->size();
  TEveElement::List_i pIdx = product->BeginChildren();
  for (int index = 0; index < static_cast<int>(size); ++index) {
    TEveElement* itemHolder = nullptr;
    if (index < product->NumChildren()) {
      itemHolder = *pIdx;
      itemHolder->SetRnrSelfChildren(true, true);
      ++pIdx;
    } else {
      itemHolder = createCompound();
      product->AddElement(itemHolder);
    }
    if (iItem->modelInfo(index).displayProperties().isVisible()) {
      const void* modelData = iItem->modelData(index);
      build(m_helper.offsetObject(modelData), index, *itemHolder, vc);
    }
  }
}
 
void FWSimpleProxyBuilder::buildViewType(const FWEventItem* iItem,
                                         TEveElementList* product,
                                         FWViewType::EType viewType,
                                         const FWViewContext* vc) {
  size_t size = iItem->size();
  TEveElement::List_i pIdx = product->BeginChildren();
  for (int index = 0; index < static_cast<int>(size); ++index) {
    TEveElement* itemHolder = nullptr;
    if (index < product->NumChildren()) {
      itemHolder = *pIdx;
      itemHolder->SetRnrSelfChildren(true, true);
      ++pIdx;
    } else {
      itemHolder = createCompound();
      product->AddElement(itemHolder);
    }
    if (iItem->modelInfo(index).displayProperties().isVisible()) {
      const void* modelData = iItem->modelData(index);
      buildViewType(m_helper.offsetObject(modelData), index, *itemHolder, viewType, vc);
    }
  }
}
 
bool FWSimpleProxyBuilder::visibilityModelChanges(const FWModelId& iId,
                                                  TEveElement* iCompound,
                                                  FWViewType::EType viewType,
                                                  const FWViewContext* vc) {
  const FWEventItem::ModelInfo& info = iId.item()->modelInfo(iId.index());
  bool returnValue = false;
  if (info.displayProperties().isVisible() && iCompound->NumChildren() == 0) {
    const void* modelData = iId.item()->modelData(iId.index());
    if (haveSingleProduct())
      build(m_helper.offsetObject(modelData), iId.index(), *iCompound, vc);
    else
      buildViewType(m_helper.offsetObject(modelData), iId.index(), *iCompound, viewType, vc);
    returnValue = true;
  }
  return returnValue;
}
 
//
// const member functions
//
 
//
// static member functions
//
std::string FWSimpleProxyBuilder::typeOfBuilder() { return std::string("simple#"); }