QtSceneGraphWidget.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
//=============================================================================
//
//  CLASS QtSceneGraphWidget - IMPLEMENTATION
//
//=============================================================================
 
//== INCLUDES =================================================================
 
 
#include "QtSceneGraphWidget.hh"
#include "QtMaterialDialog.hh"
#include "QtTextureDialog.hh"
#include "QtClippingDialog.hh"
#include "QtCoordFrameDialog.hh"
#include "QtShaderDialog.hh"
#include <QActionGroup>
 
#include "../Scenegraph/MaterialNode.hh"
#include "../Scenegraph/TextureNode.hh"
#include "../Scenegraph/ClippingNode.hh"
#include "../Scenegraph/ShaderNode.hh"
#include "../Scenegraph/CoordFrameNode.hh"
 
#include "ui_QtMaterialDialogUi.h"
 
#include <stdint.h>
 
 
//== FORWARDDECLARATIONS ======================================================
 
using ACG::SceneGraph::BaseNode;
 
 
//== NAMESPACES ===============================================================
 
namespace ACG {
namespace QtWidgets {
 
 
//== IMPLEMENTATION ========================================================== 
 
SceneGraphWidgetGenerator::SceneGraphWidgetGenerator() {
}
 
QWidget* SceneGraphWidgetGenerator::getWidget(SceneGraph::BaseNode* /*_node*/ ) {
  // Warn as this you have to derive from this class before it can be used!
  std::cerr << "SceneGraphWidgetGenerator::getWidget not implemented!"  << std::endl;
  return 0;
}
 
bool SceneGraphWidgetGenerator::canHandle(std::string _className) {
  // Warn as this you have to derive from this class before it can be used!
  std::cerr << "SceneGraphWidgetGenerator::canHandle  not implemented!" << _className << std::endl;
  return false;
}
 
std::string SceneGraphWidgetGenerator::handles() {
  // Warn as this you have to derive from this class before it can be used!
  std::cerr << "SceneGraphWidgetGenerator::canHandle  not implemented!" << std::endl;
  return std::string("Unset Type");
}
 
QString SceneGraphWidgetGenerator::contextMenuName() {
  // Warn as this you have to derive from this class before it can be used!
  std::cerr << "SceneGraphWidgetGenerator::contextMenuName  not implemented!" << std::endl;
  return QString("Context Menu name unset");
}
 
QtSceneGraphWidget::
QtSceneGraphWidget( QWidget              * _parent, 
                    SceneGraph::BaseNode * _rootNode ) :
  QTreeWidget( _parent ),
  rootNode_(0),
  curItem_(0),
  shiftPressed_(false)
 
{
  setRootIsDecorated(true);
 
  setSortingEnabled( false );
 
  setSelectionMode( QAbstractItemView::SingleSelection );
 
 
  setColumnCount( 4 );
 
  QStringList column_names;
  column_names.append( "Node" );
  column_names.append( "Type" );
  column_names.append( "Status" );
  column_names.append( "Mode" );
 
  setHeaderLabels( column_names );
 
  modeMenu_ = new QMenu( this );
 
 
  //
  // Setup the 'status' actions
  //
 
  statusActions_.menu_ = new QMenu( this );
 
  QActionGroup * status_ag = new QActionGroup( statusActions_.menu_ );
  status_ag->setExclusive( true );
 
  statusActions_.actionActive_ = new QAction( "Active", status_ag );
  statusActions_.actionActive_->setCheckable( true );
  statusActions_.actionActive_->setData( QVariant( BaseNode::Active ) );
 
  statusActions_.actionHideNode_ = new QAction( "Hide Node", status_ag );
  statusActions_.actionHideNode_->setCheckable( true );
  statusActions_.actionHideNode_->setData( QVariant( BaseNode::HideNode ) );
 
  statusActions_.actionHideChildren_ = new QAction( "Hide Children", status_ag );
  statusActions_.actionHideChildren_->setCheckable( true );
  statusActions_.actionHideChildren_->setData( QVariant( BaseNode::HideChildren ) );
 
  statusActions_.actionHideSubtree_ = new QAction( "Hide Subtree", status_ag );
  statusActions_.actionHideSubtree_->setCheckable( true );
  statusActions_.actionHideSubtree_->setData( QVariant( BaseNode::HideSubtree ) );
 
  statusActions_.menu_->addActions( status_ag->actions() );
 
  connect( status_ag, SIGNAL( triggered( QAction * ) ),
           this, SLOT( slotStatusMenu( QAction * ) ) );
 
 
 
  connect( this, SIGNAL(itemPressed(QTreeWidgetItem*,int) ),
           this, SLOT(slotItemPressed(QTreeWidgetItem*,int)) );
 
  connect( this, SIGNAL(itemExpanded(QTreeWidgetItem*) ),
           this, SLOT(slotItemExpandedOrCollapsed(QTreeWidgetItem*)) );
  connect( this, SIGNAL(itemCollapsed(QTreeWidgetItem*) ),
           this, SLOT(slotItemExpandedOrCollapsed(QTreeWidgetItem*)) );
 
  update(_rootNode);
 
  setMinimumWidth( 600 );
  setMinimumHeight( 400 );
 
}
 
 
//-----------------------------------------------------------------------------
 
 
void 
QtSceneGraphWidget::
update(ACG::SceneGraph::BaseNode* _node)
{
  rootNode_ = _node;
 
  clear();
 
  Item * item = new Item( this, _node );
 
  SceneGraph::BaseNode::ChildRIter  cRIt(_node->childrenRBegin()),
                                    cREnd(_node->childrenREnd());
  for (; cRIt != cREnd; ++cRIt)
    update(*cRIt, item);
  
  expandToDepth ( 0 ); 
 
  resizeColumnToContents( 0 );
  resizeColumnToContents( 1 );
  resizeColumnToContents( 2 );
  resizeColumnToContents( 3 );
 
  setMinimumWidth( columnWidth(0) + columnWidth(1) + columnWidth(2) + columnWidth(3) );
}
 
 
//-----------------------------------------------------------------------------
 
 
void 
QtSceneGraphWidget::
update(SceneGraph::BaseNode* _node, Item* _parent)
{
  // create new item
  Item* item = new Item( _parent, _node );
 
  // process children
  SceneGraph::BaseNode::ChildRIter  cRIt(_node->childrenRBegin()),
                                    cREnd(_node->childrenREnd());
  for (; cRIt != cREnd; ++cRIt)
    update(*cRIt, item);
}
 
 
//-----------------------------------------------------------------------------
 
 
void 
QtSceneGraphWidget::
slotItemExpandedOrCollapsed( QTreeWidgetItem* /*_item*/ )
{
  resizeColumnToContents( 0 );
}
 
 
//-----------------------------------------------------------------------------
 
 
void 
QtSceneGraphWidget::
slotItemPressed( QTreeWidgetItem * _item,
                 int _col)
{
 
  if ( _item )
  {
    curItem_ = static_cast<Item* >(_item);
    BaseNode * node = curItem_->node();
 
    switch ( _col )
    {
      case 2:
      {
        statusActions_.actionActive_      ->setChecked( false );
        statusActions_.actionHideNode_    ->setChecked( false );
        statusActions_.actionHideChildren_->setChecked( false );
        statusActions_.actionHideSubtree_ ->setChecked( false );
 
        switch ( node->status() )
        {
          case BaseNode::Active:
            statusActions_.actionActive_->setChecked( true );
            break;
          case BaseNode::HideNode:
            statusActions_.actionHideNode_->setChecked( true );
            break;
          case BaseNode::HideChildren:
            statusActions_.actionHideChildren_->setChecked( true );
            break;
          case BaseNode::HideSubtree:
            statusActions_.actionHideSubtree_->setChecked( true );
            break;
        }
        statusActions_.menu_->popup( QCursor::pos() ); 
        break;
      }
      case 0: break;
      case 1: break;
      case 3:
      {
        modeMenu_->clear();
 
        QActionGroup * modeGroup = new QActionGroup( modeMenu_ );
        modeGroup->setExclusive( true );
        connect( modeGroup, SIGNAL( triggered( QAction * ) ),
                  this, SLOT( slotModeMenu( QAction * ) ) );
 
        ACG::SceneGraph::DrawModes::DrawMode availDrawModes( node->availableDrawModes() );
        availDrawModes |= SceneGraph::DrawModes::DEFAULT;
        
        ACG::SceneGraph::DrawModes::DrawMode currentDrawMode( node->drawMode() );
 
        std::vector< ACG::SceneGraph::DrawModes::DrawMode > available_modes( availDrawModes.getAtomicDrawModes() );
 
        
        for ( unsigned int i = 0; i < available_modes.size(); ++i )
        {
          ACG::SceneGraph::DrawModes::DrawMode id    = available_modes[i];
          std::string  descr = id.description();
 
          QAction * action = new QAction( descr.c_str(), modeGroup );
          action->setCheckable( true );
          action->setChecked ( currentDrawMode.containsAtomicDrawMode(id ) ) ;
          action->setData( QVariant( quint64(id.getIndex()) ) );
        }
 
        modeMenu_->addActions( modeGroup->actions() );
 
        if ( dynamic_cast<SceneGraph::MaterialNode*>( node ) )
        {
          modeMenu_->addSeparator();
          QAction * action = modeMenu_->addAction( "Edit material" );
          connect( action, SIGNAL( triggered() ),
                    this, SLOT( slotEditMaterial() ) );
        }
        
        if ( dynamic_cast<SceneGraph::TextureNode*>( node ) )
        {
          modeMenu_->addSeparator();
          QAction * action = modeMenu_->addAction( "Edit texture" );
          connect( action, SIGNAL( triggered() ),
                    this, SLOT( slotEditTexture() ) );
        }
        
        if ( dynamic_cast<SceneGraph::ShaderNode*>( node ) )
        {
          modeMenu_->addSeparator();
          QAction * action = modeMenu_->addAction( "Edit shaders" );
          connect( action, SIGNAL( triggered() ),
                    this, SLOT( slotEditShader() ) );
        }        
 
        if ( dynamic_cast<SceneGraph::ClippingNode*>( node ) )
        {
          modeMenu_->addSeparator();
          QAction * action = modeMenu_->addAction( "Edit clip planes" );
          connect( action, SIGNAL( triggered() ),
                    this, SLOT( slotEditClipPlanes() ) );
        }
 
        if ( dynamic_cast<SceneGraph::CoordFrameNode*>( node ) )
        {
          modeMenu_->addSeparator();
          QAction * action = modeMenu_->addAction( "Edit coord frame" );
          connect( action, SIGNAL( triggered() ),
                    this, SLOT( slotEditCoordinateFrame() ) );
        }
 
        // Add widgets through generator
        if ( generatorMap_.contains( node->className() ) ) {
          QWidget* widget = generatorMap_[node->className()]->getWidget( node );
          modeMenu_->addAction( generatorMap_[node->className()]->contextMenuName() , widget, SLOT(show()) );
        } 
 
        modeMenu_->popup( QCursor::pos() );
 
        break;
      }
      default: break;
    }
  }
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotEditMaterial()
{
  if ( curItem_ )
  {
    SceneGraph::MaterialNode * node =
      dynamic_cast< SceneGraph::MaterialNode * >( curItem_->node() );
 
    QtMaterialDialog* dialog = new QtMaterialDialog( this, node );
 
    connect(dialog, 
            SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
            this, 
            SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)));
 
    dialog->show();
  }
}
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotEditTexture()
{
  if ( curItem_ )
  {
    SceneGraph::TextureNode * node =
      dynamic_cast< SceneGraph::TextureNode * >( curItem_->node() );
 
    QtTextureDialog* dialog = new QtTextureDialog( this, node );
 
    connect(dialog, 
        SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
        this, 
        SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)));
 
    dialog->show();
  }
}
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotEditShader()
{
  if ( curItem_ )
  {
    SceneGraph::ShaderNode * node =
        dynamic_cast< SceneGraph::ShaderNode * >( curItem_->node() );
 
    QtShaderDialog* dialog = new QtShaderDialog( this, node );
 
    connect(dialog, 
            SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
                   this, 
                   SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)));
 
    dialog->show();
  }
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotEditClipPlanes()
{
  if ( curItem_ )
  {
    SceneGraph::ClippingNode * node =
      dynamic_cast< SceneGraph::ClippingNode * >( curItem_->node() );
 
    QtClippingDialog * dialog = new QtClippingDialog( this, node );
 
    connect(dialog, 
            SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
            this, 
            SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)));
 
    dialog->show();
  }
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotEditCoordinateFrame()
{
  if ( curItem_ )
  {
    SceneGraph::CoordFrameNode * node =
      dynamic_cast< SceneGraph::CoordFrameNode * >( curItem_->node() );
 
    QtCoordFrameDialog * dialog = new QtCoordFrameDialog( this, node );
 
    connect(dialog, 
            SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
            this, 
            SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)));
 
    dialog->show();
  }
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotModeMenu( QAction * _action )
{
  SceneGraph::DrawModes::DrawMode new_drawmode( _action->data().toUInt());
 
  curItem_->node()->drawMode( new_drawmode );
  curItem_->update();
  emit signalNodeChanged( curItem_->node() );
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::slotStatusMenu( QAction * _action )
{
  if ( curItem_ )
  {
    unsigned int status = _action->data().toUInt();
    BaseNode * node = curItem_->node();
 
    node->set_status( (ACG::SceneGraph::BaseNode::StatusMode) status );
    curItem_->update();
    emit signalNodeChanged( node );
  }
}
 
 
//-----------------------------------------------------------------------------
 
 
void QtSceneGraphWidget::keyPressEvent(QKeyEvent* _event)
{
  switch(_event->key())
  {
    case Qt::Key_Shift:  shiftPressed_ = true; break;
    default : _event->ignore();
  }
}
 
 
void QtSceneGraphWidget::keyReleaseEvent(QKeyEvent *_event)
{
  switch(_event->key())
  {
    case Qt::Key_Shift: shiftPressed_ = false; break;
    default : _event->ignore();
  }
}
 
 
//-----------------------------------------------------------------------------
 
void QtSceneGraphWidget::expandAll() {
    
    QTreeWidget::expandAll();
    
    resizeColumnToContents(0);
}
 
void QtSceneGraphWidget::updateAll() {
 
    if(rootNode_) {
        update(rootNode_);
        QTreeWidget::expandAll();
    }
 
    resizeColumnToContents(0);
}
 
//-----------------------------------------------------------------------------
 
void 
QtSceneGraphWidget::
slotNodeChanged(ACG::SceneGraph::BaseNode* _node)
{
  emit signalNodeChanged(_node);
}
 
//-----------------------------------------------------------------------------
 
bool QtSceneGraphWidget::addWidgetGenerator( SceneGraphWidgetGenerator* _generator )  {
  // Check if we already have a generator for this type.
  if ( generatorMap_.contains( _generator->handles() ) ) {
    std::cerr << "Already handled" << std::endl;
    return false;
  }
 
  // Store the generator
  generatorMap_[_generator->handles() ] = _generator;
 
  return true;
}
 
 
//=============================================================================
 
 
 
 
QtSceneGraphWidget::Item::Item( QTreeWidget * _parent,
                                SceneGraph::BaseNode* _node )
  : QTreeWidgetItem(_parent), node_(_node)
{ 
  update(); 
}
 
 
//-----------------------------------------------------------------------------
 
 
QtSceneGraphWidget::Item::Item( Item * _parent,
                                SceneGraph::BaseNode* _node )
  : QTreeWidgetItem(_parent), node_(_node)
{ 
  update(); 
}
 
 
//-----------------------------------------------------------------------------
 
 
void
QtSceneGraphWidget::Item::update()
{
  QString name = tr("%1 @ 0x%2")
          .arg(node_->name().c_str())
          .arg(reinterpret_cast<uintptr_t>(node_), 0, 16);
  setText( 0, name.toStdString().c_str());
  setText( 1, node_->className().c_str());
 
  switch (node_->status())
  {
    case BaseNode::Active:        setText( 2, "Active");       break;
    case BaseNode::HideNode:      setText( 2, "HideNode");     break;
    case BaseNode::HideChildren:  setText( 2, "HideChildren"); break;
    case BaseNode::HideSubtree:   setText( 2, "HideSubtree");  break;
  }
 
  setText( 3, node_->drawMode().description().c_str());
}
 
 
//-----------------------------------------------------------------------------
 
 
QtSceneGraphDialog::
QtSceneGraphDialog( QWidget* _parent,
                    SceneGraph::BaseNode* _rootNode )
  : QDialog(_parent)
{
  setModal( false );
  
  QVBoxLayout* l = new QVBoxLayout( this );
  
  QWidget* buttons = new QWidget(this);
  QHBoxLayout* butLayout = new QHBoxLayout(buttons);
  
  sgw_ = 
    new QtSceneGraphWidget( this, _rootNode );
 
    // Add buttons to hbox layout
    QPushButton* expAll = new QPushButton("Expand all");
    QPushButton* collAll = new QPushButton("Collapse all");
    QPushButton* updAll = new QPushButton("Update all");
    
    butLayout->addWidget(expAll);
    butLayout->addWidget(collAll);
    butLayout->addWidget(updAll);
    
  l->addWidget(buttons);
  l->addWidget(sgw_);
 
  connect(sgw_, 
        SIGNAL(signalNodeChanged(ACG::SceneGraph::BaseNode*)),
        this, 
        SLOT(slotNodeChanged(ACG::SceneGraph::BaseNode*)) );
       
  connect(expAll, SIGNAL(pressed()), sgw_, SLOT(expandAll()));
  connect(collAll, SIGNAL(pressed()), sgw_, SLOT(collapseAll()));
  connect(updAll, SIGNAL(pressed()), sgw_, SLOT(updateAll()));
}
 
 
//-----------------------------------------------------------------------------
 
 
void
QtSceneGraphDialog::
slotNodeChanged(ACG::SceneGraph::BaseNode* _node)
{
  emit(signalNodeChanged(_node));
}
 
 
//-----------------------------------------------------------------------------
 
 
void
QtSceneGraphDialog::
update(ACG::SceneGraph::BaseNode* _rootNode)
{
  sgw_->update(_rootNode);
}
 
 
//=============================================================================
} // namespace QtWidgets
} // namespace ACG
//=============================================================================