VP1HEPVisUtils::Imp Class Reference

Collaboration diagram for VP1HEPVisUtils::Imp:

Static Public Member Functions
template<class T >
static SoNode *	convertToAlternateRep (SoNode *)
template<class T >
static void	clearAlternateRep (SoNode *)
template<class T >
static void	updateAlternateRepIfNull (SoNode *)
static bool	isGroup (SoNode *n)
static bool	isNonCustomTree (SoGroup *g)
static SoGroup *	convertToStandardGroupNode (SoGroup *g, bool transferChildren)
static SoGroup *	convertToStandardScene (SoGroup *g)
static void	updateAllNullAlternativeReps (SoGroup *g)

Detailed Description

Definition at line 42 of file VP1HEPVisUtils.cxx.

Member Function Documentation

clearAlternateRep()

template<class T >

void VP1HEPVisUtils::Imp::clearAlternateRep ( SoNode *  n )

static

Definition at line 219 of file VP1HEPVisUtils.cxx.

{
  T * t = static_cast<T*>(n);
  if (t&&t->alternateRep.getValue())
    t->clearAlternateRep();
}

convertToAlternateRep()

template<class T >

SoNode * VP1HEPVisUtils::Imp::convertToAlternateRep ( SoNode *  n )

static

Definition at line 193 of file VP1HEPVisUtils.cxx.

{
  if (!n)
    return 0;
  T * t = static_cast<T*>(n);
  SoNode * n_alt = t->alternateRep.getValue();
  if (n_alt) {
    //Don't clear the alternateRep, since it was there before.
  } else {
    t->generateAlternateRep();
    n_alt = t->alternateRep.getValue();
    if (n_alt) {
      //Clear the alternateRep, since it was not there before.
      n_alt->ref();
      t->clearAlternateRep();
      n_alt->unrefNoDelete();
    } else {
      return 0;
    }
  }
  n_alt->setName(n->getName());
  return n_alt;
}

convertToStandardGroupNode()

SoGroup * VP1HEPVisUtils::Imp::convertToStandardGroupNode ( SoGroup *  g, bool  transferChildren  )

static

Definition at line 83 of file VP1HEPVisUtils.cxx.

{
  //Create new non-custom node and transfer relevant fields:
  SoGroup * newgroup(0);
  if ( g->getTypeId().isDerivedFrom(SoSeparator::getClassTypeId()) &&
       ! g->getTypeId().isDerivedFrom(SoSelection::getClassTypeId()) ) {
    SoSeparator * sep = new SoSeparator;
    SoSeparator * origsep = static_cast<SoSeparator*>(g);
    sep->renderCaching.setValue(origsep->renderCaching.getValue());
    sep->boundingBoxCaching.setValue(origsep->boundingBoxCaching.getValue());
    sep->renderCulling.setValue(origsep->renderCulling.getValue());
    sep->pickCulling.setValue(origsep->pickCulling.getValue());
    newgroup = sep;
  } else if ( g->getTypeId().isDerivedFrom(SoSelection::getClassTypeId()) ) {
    SoSelection * sel = new SoSelection;
    SoSelection * origsel = static_cast<SoSelection*>(g);
    sel->renderCaching.setValue(origsel->renderCaching.getValue());
    sel->boundingBoxCaching.setValue(origsel->boundingBoxCaching.getValue());
    sel->renderCulling.setValue(origsel->renderCulling.getValue());
    sel->pickCulling.setValue(origsel->pickCulling.getValue());
    sel->policy.setValue(origsel->policy.getValue());
    newgroup = sel;
  } else if ( g->getTypeId().isDerivedFrom(SoSwitch::getClassTypeId()) ) {
    SoSwitch *sw = new SoSwitch;
    sw->whichChild.setValue(static_cast<SoSwitch*>(g)->whichChild.getValue());
    newgroup = sw;
  } else {
    //Everything else is just treated like a group (we could add more specialisations):
    newgroup = new SoGroup;
  }
 
  //Transfer name:
  newgroup->setName(g->getName());
 
  //Transfer children:
  if (transferChildren)
    for (int i = 0; i<g->getNumChildren();++i)
      newgroup->addChild(g->getChild(i));
 
  return newgroup;
}

convertToStandardScene()

SoGroup * VP1HEPVisUtils::Imp::convertToStandardScene ( SoGroup *  g )

static

Definition at line 126 of file VP1HEPVisUtils.cxx.

{
  if (Imp::isNonCustomTree(g))
    return g;
 
  //We have to change something underneath, so we must get a new (and non-custom) group node:
  SoGroup * thegroup = convertToStandardGroupNode(g,false/*don't transfer children*/);
  if (!thegroup)
    std::cout <<"BAAAAAAAAAD!"<<std::endl;
  for (int i = 0; i<g->getNumChildren();++i) {
    SoNode * n = g->getChild(i);
    if (isGroup(n)) {
      SoGroup * standard = convertToStandardScene(static_cast<SoGroup*>(n));
      if (standard)
    thegroup->addChild(standard);
      else
    std::cout <<"BAD 1"<<std::endl;
    } else {
      SoNode * ntoadd = isCustomNode(n)?convertCustomNodeToAlternateRep(n):n;
      if (ntoadd)
    thegroup->addChild(isCustomNode(n)?convertCustomNodeToAlternateRep(n):n);
      else
    std::cout <<"BAD 2"<<std::endl;
    }
  }
 
  return thegroup;
}

isGroup()

bool VP1HEPVisUtils::Imp::isGroup ( SoNode *  n )

static

Definition at line 261 of file VP1HEPVisUtils.cxx.

{
  return n->getTypeId().isDerivedFrom(SoGroup::getClassTypeId());
}

isNonCustomTree()

bool VP1HEPVisUtils::Imp::isNonCustomTree ( SoGroup *  g )

static

Definition at line 61 of file VP1HEPVisUtils.cxx.

{
  if (!g)
    return true;//well...
 
  if (isCustomNode(g))
    return false;
 
  for (int i = 0; i<g->getNumChildren();++i) {
    SoNode * n = g->getChild(i);
    if ( Imp::isGroup(n) ) {
      if (!isNonCustomTree(static_cast<SoGroup*>(n)))
    return false;
    } else {
      if (isCustomNode(n))
    return false;
    }
  }
  return true;
}

updateAllNullAlternativeReps()

void VP1HEPVisUtils::Imp::updateAllNullAlternativeReps ( SoGroup *  g )

static

Definition at line 267 of file VP1HEPVisUtils.cxx.

{
  for (int i = 0; i<g->getNumChildren();++i) {
    SoNode * n = g->getChild(i);
    if ( Imp::isGroup(n) ) {
      updateAllNullAlternativeReps(static_cast<SoGroup*>(n));
    } else if (VP1HEPVisUtils::isCustomNode(n)) {
      if ( n->getTypeId().isDerivedFrom(SoCons::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoCons>(n);
      if ( n->getTypeId().isDerivedFrom(SoLAr::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoLAr>(n);
      //NOT IMPLEMENTED if ( n->getTypeId().isDerivedFrom(SoPcons::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoPcons>(n);
      if ( n->getTypeId().isDerivedFrom(SoPcons::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoPcons>(n);
      if ( n->getTypeId().isDerivedFrom(SoGenericBox::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoGenericBox>(n);
      if ( n->getTypeId().isDerivedFrom(SoTubs::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoTubs>(n);
      if ( n->getTypeId().isDerivedFrom(SoPolyhedron::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoPolyhedron>(n);
      if ( n->getTypeId().isDerivedFrom(SoTessellated::getClassTypeId()) ) return Imp::updateAlternateRepIfNull<SoTessellated>(n);
    }
  }
}

updateAlternateRepIfNull()

template<class T >

void VP1HEPVisUtils::Imp::updateAlternateRepIfNull ( SoNode *  n )

static

Definition at line 228 of file VP1HEPVisUtils.cxx.

{
  T * t = static_cast<T*>(n);
  if (t&&!t->alternateRep.getValue()) {
    t->generateAlternateRep();
    t->clearAlternateRep();
  }
}

---

The documentation for this class was generated from the following file:

• VP1HEPVisUtils.cxx