"NOT SALOME_KERNEL_LIGHT_ONLY" ON)
OPTION(SALOME_USE_VTKVIEWER "Enable VTK visualization (Mandatory in classic configurations)" ON)
OPTION(SALOME_USE_OCCVIEWER "Enable OCC visualization (Mandatory in classic configurations)" ON)
+#MBS
+OPTION(SALOME_USE_PV3DVIEWER "Enable ParaView3D visualization (Optionally in classic configurations)" ON)
OPTION(SALOME_USE_GLVIEWER "Enable OpenGL visualization (Mandatory in classic configurations)" ON)
OPTION(SALOME_USE_GRAPHICSVIEW "Enable GraphicsView visualization (Mandatory in classic configurations)" ON)
OPTION(SALOME_USE_PYVIEWER "Enable Python viewer (Mandatory in classic configurations)" ON)
MARK_AS_ADVANCED(SALOME_LIGHT_ONLY SALOME_USE_VTKVIEWER SALOME_USE_GRAPHICSVIEW SALOME_USE_PVVIEWER)
MARK_AS_ADVANCED(SALOME_USE_SALOMEOBJECT SALOME_USE_OCCVIEWER SALOME_USE_GLVIEWER SALOME_USE_PLOT2DVIEWER)
-MARK_AS_ADVANCED(SALOME_USE_PYCONSOLE SALOME_USE_QXGRAPHVIEWER SALOME_USE_PYVIEWER)
+MARK_AS_ADVANCED(SALOME_USE_PYCONSOLE SALOME_USE_QXGRAPHVIEWER SALOME_USE_PYVIEWER SALOME_USE_PV3DVIEWER)
# Prerequisites
# =============
ADD_DEFINITIONS("-DDISABLE_PVVIEWER")
ENDIF()
+# - PV3D viewer: ParaView3D
+#MBS:
+IF (SALOME_USE_PV3DVIEWER)
+ FIND_PACKAGE(SalomeParaView)
+ SALOME_LOG_OPTIONAL_PACKAGE(ParaView SALOME_USE_PV3DVIEWER)
+ELSE()
+ ADD_DEFINITIONS("-DDISABLE_PV3DVIEWER")
+ENDIF()
+
# - VTK viewer: VTK
IF(SALOME_USE_VTKVIEWER)
# Required components are listed in the FindSalomeVTK.cmake file:
ENDIF(SALOME_USE_SALOMEOBJECT)
ENDIF(SALOME_USE_OCCVIEWER)
+# PV3D specific targets:
+IF(SALOME_USE_PV3DVIEWER)
+ LIST(APPEND _${PROJECT_NAME}_exposed_targets
+ PV3DViewer)
+ IF(SALOME_USE_SALOMEOBJECT)
+ LIST(APPEND _${PROJECT_NAME}_exposed_targets
+ SPV3D)
+ ENDIF(SALOME_USE_SALOMEOBJECT)
+ENDIF(SALOME_USE_PV3DVIEWER)
+
# Plot2d specific targets:
IF(SALOME_USE_PLOT2DVIEWER)
LIST(APPEND _${PROJECT_NAME}_exposed_targets
SET(SALOME_USE_OCCVIEWER @SALOME_USE_OCCVIEWER@)
SET(SALOME_USE_GLVIEWER @SALOME_USE_GLVIEWER@)
SET(SALOME_USE_VTKVIEWER @SALOME_USE_VTKVIEWER@)
+#MBS:
+SET(SALOME_USE_PV3DVIEWER @SALOME_USE_PV3DVIEWER@)
SET(SALOME_USE_PLOT2DVIEWER @SALOME_USE_PLOT2DVIEWER@)
SET(SALOME_USE_GRAPHICSVIEW @SALOME_USE_GRAPHICSVIEW@)
SET(SALOME_USE_QXGRAPHVIEWER @SALOME_USE_QXGRAPHVIEWER@)
IF(NOT SALOME_USE_OCCVIEWER)
LIST(APPEND GUI_DEFINITIONS "-DDISABLE_OCCVIEWER")
ENDIF()
+#MBS:
+IF(NOT SALOME_USE_PV3DVIEWER)
+ LIST(APPEND GUI_DEFINITIONS "-DDISABLE_PV3DVIEWER")
+ENDIF()
IF(NOT SALOME_USE_GLVIEWER)
LIST(APPEND GUI_DEFINITIONS "-DDISABLE_GLVIEWER")
ENDIF()
SET(GUI_SalomeSession SalomeSession)
SET(GUI_SalomeStyle SalomeStyle)
SET(GUI_SOCC SOCC)
+#MBS
+SET(GUI_SPV3D SPV3D)
SET(GUI_SPlot2d SPlot2d)
SET(GUI_std std)
SET(GUI_SUITApp SUITApp)
SET(GUI_ViewerTools ViewerTools)
SET(GUI_ViewerData ViewerData)
SET(GUI_VTKViewer VTKViewer)
+#MBS:
+SET(GUI_PV3DViewer PV3DViewer)
SET(GUI_PVViewer PVViewer)
SET(GUI_PVServerService PVServerService)
SET(GUI_vtkTools vtkTools)
ENDIF(SALOME_USE_SALOMEOBJECT)
ENDIF(SALOME_USE_OCCVIEWER)
+##
+# ParaView3D Viewer
+##
+#MBS:
+IF(SALOME_USE_PV3DVIEWER)
+ ADD_SUBDIRECTORY(PV3DViewer)
+ # ADD_SUBDIRECTORY(PV3DServerService)
+ IF(SALOME_USE_SALOMEOBJECT)
+ ADD_SUBDIRECTORY(SPV3D)
+ ENDIF(SALOME_USE_SALOMEOBJECT)
+ENDIF()
+
##
# Plot2d viewer
##
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/SOCC)
ENDIF()
ENDIF()
+#MBS:
+IF(SALOME_USE_PV3DVIEWER)
+ INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/PV3DViewer)
+ IF(SALOME_USE_SALOMEOBJECT)
+ INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/SPV3D)
+ ENDIF()
+ENDIF()
IF(SALOME_USE_PLOT2DVIEWER)
INCLUDE_DIRECTORIES(${QWT_INCLUDE_DIR})
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/Plot2d)
LIST(APPEND _link_LIBRARIES SOCC)
ENDIF()
ENDIF()
+#MBS
+IF(SALOME_USE_PV3DVIEWER)
+ LIST(APPEND _link_LIBRARIES PV3DViewer)
+ IF(SALOME_USE_SALOMEOBJECT)
+ LIST(APPEND _link_LIBRARIES SPV3D)
+ ENDIF()
+ENDIF()
IF(SALOME_USE_PLOT2DVIEWER)
LIST(APPEND _link_LIBRARIES Plot2d)
IF(SALOME_USE_SALOMEOBJECT)
IF(SALOME_USE_OCCVIEWER)
LIST(APPEND _moc_HEADERS LightApp_OCCSelector.h)
ENDIF()
+# MBS:
+IF(SALOME_USE_PV3DVIEWER)
+ IF(SALOME_USE_SALOMEOBJECT)
+ LIST(APPEND _moc_HEADERS LightApp_PV3DSelector.h)
+ ENDIF()
+ENDIF()
IF(SALOME_USE_PLOT2DVIEWER)
LIST(APPEND _moc_HEADERS LightApp_Plot2dSelector.h)
ENDIF()
IF(SALOME_USE_OCCVIEWER)
LIST(APPEND _other_SOURCES LightApp_OCCSelector.cxx)
ENDIF()
+# MBS:
+IF(SALOME_USE_PV3DVIEWER)
+ IF(SALOME_USE_SALOMEOBJECT)
+ LIST(APPEND _other_SOURCES LightApp_PV3DSelector.cxx)
+ ENDIF()
+ENDIF()
IF(SALOME_USE_PLOT2DVIEWER)
LIST(APPEND _other_SOURCES LightApp_Plot2dSelector.cxx)
ENDIF()
#include <PyViewer_ViewWindow.h>
#endif
+//MBS:
+#ifndef DISABLE_PV3DVIEWER
+#ifndef DISABLE_SALOMEOBJECT
+ #include <SPV3D_ViewModel.h>
+ #include <SPV3D_ViewManager.h>
+ #include "LightApp_PV3DSelector.h"
+#else
+ #include <PV3DViewer_ViewModel.h>
+ #include <PV3DViewer_ViewManager.h>
+#endif
+ #include <PV3DViewer_ViewManager.h>
+ #include <PV3DViewer_ViewModel.h>
+ #include "PV3DViewer_ViewWindow.h"
+#endif
+
#define VISIBILITY_COLUMN_WIDTH 25
#ifndef DISABLE_PYVIEWER
createActionForViewer( NewPyViewerId, newWinMenu, QString::number( 7 ), Qt::ALT+Qt::Key_Y );
#endif
+#ifndef DISABLE_PV3DVIEWER
+ createActionForViewer( NewPV3DViewId, newWinMenu, QString::number( 8 ), Qt::ALT+Qt::Key_3 );//MBS:
+#endif
createAction( RenameId, tr( "TOT_RENAME" ), QIcon(), tr( "MEN_DESK_RENAME" ), tr( "PRP_RENAME" ),
Qt::ALT+Qt::SHIFT+Qt::Key_R, desk, false, this, SLOT( onRenameWindow() ) );
else {
// cancelled
putInfo( tr("INF_CANCELLED") );
+ MSGEL("-----> emit moduleActivated <-----");
emit moduleActivated( QString() );
cancelled = true;
}
case NewPyViewerId:
type = PyViewer_Viewer::Type();
break;
+#endif
+#ifndef DISABLE_PV3DVIEWER
+ case NewPV3DViewId:
+ type = PV3DViewer_ViewModel::Type();//MBS:
+ break;
#endif
}
SHOW(type);
if( a )
a->setEnabled( activeStudy() );
#endif
+
+#ifndef DISABLE_PV3DVIEWER
+ a = action( NewPV3DViewId );//MBS:
+ if( a )
+ a->setEnabled( activeStudy() );
+#endif
}
/*!
resMgr->booleanValue( "OCCViewer", "clipping_modulate", vm->isTextureModulated() ),
resMgr->doubleValue( "OCCViewer", "clipping_scale", vm->clippingTextureScale() ) );
-
viewMgr->setViewModel( vm );// custom view model, which extends SALOME_View interface
new LightApp_OCCSelector( (OCCViewer_Viewer*)viewMgr->getViewModel(), mySelMgr );
}
}
#endif
+// //MBS:
+// #ifndef DISABLE_PV3DVIEWER
+// if( vmType == PV3DViewer_ViewModel::Type() )
+// {
+// // if (( viewMgr = dynamic_cast<PV3DViewer_ViewManager*>( getViewManager( vmType, false )))) {
+// // viewMgr->getActiveView()->setFocus();
+// // return 0;
+// // } else {
+// // viewMgr = new PV3DViewer_ViewManager( activeStudy(), desktop() );
+// // }
+//
+// viewMgr = new SPV3D_ViewManager( activeStudy(), desktop() );
+// SPV3D_ViewModel* vm = dynamic_cast<SPV3D_ViewModel*>( viewMgr->getViewModel() );
+// if (vm)
+// {
+// // Initalize all view parameters
+// //vm->setXXX(); // NYI
+//
+// //new LightApp_PV3DSelector(vm, mySelMgr);
+// }
+// }
+// #endif
+
+//MBS:
+#ifndef DISABLE_PV3DVIEWER
+# ifndef DISABLE_SALOMEOBJECT
+ if ( vmType == SPV3D_ViewModel::Type() )
+# else
+ if ( vmType == PV3DViewer_ViewModel::Type() )
+# endif
+ {
+ viewMgr = new SPV3D_ViewManager( activeStudy(), desktop() );
+ SPV3D_ViewModel* vm = dynamic_cast<SPV3D_ViewModel*>( viewMgr->getViewModel() );
+ if ( vm )
+ {
+ // vm->setBackground(...); //NYI
+ // vm->...
+
+ new LightApp_PV3DSelector( vm, mySelMgr );
+ }
+#else
+ viewMgr = new PV3DViewer_ViewManager( activeStudy(), desktop() );
+ PV3DViewer_ViewModel* vm = dynamic_cast<PV3DViewer_ViewModel*>( viewMgr->getViewModel() );
+ if ( vm )
+ {
+ // vm->setBackground(...); //NYI
+ }
+#endif
+ }
+
if ( !viewMgr )
return 0;
getPyInterp()->initStudy();
#endif
+ MSGEL("-----> emit studyOpened <-----");
emit studyOpened();
}
if ( mru && s )
mru->insert( s->studyName() );
+ MSGEL("-----> emit studySaved <-----");
emit studySaved();
}
mySelMgr->clearSelected();
// Bug 12944: emit signal only after clear selection
+ MSGEL("-----> emit studyClosed <-----");
emit studyClosed();
activateModule( "" );
else
preferencesChanged( section, param );
// emit signal to allow additional preferences changing processing
+ MSGEL("-----> emit preferenceChanged <-----");
emit preferenceChanged( modName, section, param );
}
*/
void LightApp_Application::updateModuleActions()
{
+ MSGEL("-----> emit moduleActivated <-----");
emit moduleActivated( activeModule() ? activeModule()->moduleName() : QString() );
}
#else
aTypesList<<VTKViewer_Viewer::Type();
#endif
+#endif
+#ifndef DISABLE_PV3DVIEWER
+ aTypesList<<PV3DViewer_ViewModel::Type(); //MBS:
#endif
return aTypesList;
}
const QString& theOperationName,
const QStringList& theEntryList )
{
+ MSGEL("-----> emit operationFinished(\"" << theModuleName.toStdString() << "\", \"" << theOperationName.toStdString() << "\") <-----");
emit operationFinished( theModuleName, theOperationName, theEntryList );
}
CloseId, CloseAllId, GroupAllId,
PreferencesId, MRUId, ModulesListId,
NewGLViewId, NewPlot2dId, NewOCCViewId, NewVTKViewId,
- NewQxSceneViewId, NewGraphicsViewId, NewPVViewId, NewPyViewerId, StyleId, FullScreenId,
+ NewQxSceneViewId, NewGraphicsViewId, NewPVViewId, NewPyViewerId, /*MBS:*/ NewPV3DViewId, StyleId, FullScreenId,
WebSiteId, ForumId, VideosId, TutorialsId,
UserID };
bool LightApp_DataModel::open( const QString&, CAM_Study*, QStringList )
{
DBG_FUN();
+ MSGEL("-----> emit opened <-----");
emit opened(); //TODO: is it really needed? to be removed maybe...
return true;
}
bool LightApp_DataModel::save( QStringList& )
{
DBG_FUN();
+ MSGEL("-----> emit saved <-----");
emit saved();
return true;
}
bool LightApp_DataModel::saveAs( const QString&, CAM_Study*, QStringList& )
{
DBG_FUN();
+ MSGEL("-----> emit saved <-----");
emit saved();
return true;
}
bool LightApp_DataModel::close()
{
DBG_FUN();
+ MSGEL("-----> emit closed <-----");
emit closed();
return true;
}
#include <PVViewer_ViewManager.h>
#include <PVViewer_ViewWindow.h>
#endif
+//MBS:
+#ifndef DISABLE_PV3DVIEWER
+// #ifndef DISABLE_SALOMEOBJECT
+// #include <SPV3D_ViewWindow.h>
+// #include <SPV3D_ViewModel.h>
+// #else
+ #include <PV3DViewer_ViewWindow.h>
+// #endif
+ #include <PV3DViewer_ViewModel.h>
+#endif
+
+//MBS:
+#ifndef DISABLE_PV3DVIEWER
+ #include <PV3DViewer_ViewManager.h>
+ #include <PV3DViewer_ViewWindow.h>
+#endif
+
+
#ifndef DISABLE_PLOT2DVIEWER
#include <Plot2d_ViewWindow.h>
#include <Plot2d_ViewFrame.h>
( (VTKViewer_ViewWindow*)viewWnd )->Repaint();
#endif
#endif
+//MBS:
+#ifndef DISABLE_PV3DVIEWER
+ // if ( viewWnd->inherits( "SPV3D_ViewWindow" ) )
+ // ( (SPV3D_ViewWindow*)viewWnd )->Repaint();
+ // if ( viewWnd->inherits( "PV3DViewer_ViewWindow" ) )
+ // ( (PV3DViewer_ViewWindow*)viewWnd )->getMultiViewManager()->Repaint();
+#endif
#ifndef DISABLE_OCCVIEWER
if ( viewWnd->inherits( "OCCViewer_ViewWindow" ) )
( (OCCViewer_ViewWindow*)viewWnd )->getViewPort()->onUpdate();
viewers.append( VTKViewer_Viewer::Type() );
#endif
#endif
+#ifndef DISABLE_PV3DVIEWER
+// #ifndef DISABLE_SALOMEOBJECT
+// viewers.append( SPV3D_ViewModel::Type() );
+// #else
+ viewers.append( PV3DViewer_ViewModel::Type() );
+// #endif
+#endif
#ifndef DISABLE_PLOT2DVIEWER
#ifndef DISABLE_SALOMEOBJECT
viewers.append( SPlot2d_Viewer::Type() );
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "LightApp_PV3DSelector.h"
+#include "LightApp_DataOwner.h"
+
+#include "SUIT_Desktop.h"
+
+#ifndef DISABLE_PV3DVIEWER
+ #include "SPV3D_ViewModel.h"
+ #include "SPV3D_ViewManager.h"
+ #include "SPV3D_ViewWindow.h"
+ #include <vtkRenderer.h>
+#endif
+
+#ifndef DISABLE_SALOMEOBJECT
+ // #include "SALOME_Actor.h"
+ // #include "SALOME_ListIO.hxx"
+#endif
+
+#include <utilities.h>
+
+//---------------------------------------------------------
+#define USE_DEBUG
+#define MBCLASSNAME "LightApp_PV3DSelector"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+
+#ifndef DISABLE_PV3DVIEWER
+/*!
+ Constructor.
+*/
+LightApp_PV3DSelector::LightApp_PV3DSelector( SPV3D_ViewModel* viewer, SUIT_SelectionMgr* mgr )
+: SUIT_Selector( mgr, viewer ),
+ myViewer( viewer )
+{
+ DBG_FUN();
+ if ( myViewer )
+ connect( myViewer, SIGNAL( selectionChanged() ), this, SLOT( onSelectionChanged() ) );
+}
+
+/*!
+ Gets viewer.
+*/
+SPV3D_ViewModel* LightApp_PV3DSelector::viewer() const
+{
+ return myViewer;
+}
+
+/*!
+ Gets type of salome PV3D viewer.
+*/
+QString LightApp_PV3DSelector::type() const
+{
+ return myViewer->getType();
+}
+
+#endif
+
+/*!
+ On selection changed.
+*/
+void LightApp_PV3DSelector::onSelectionChanged()
+{
+ DBG_FUN();
+ selectionChanged();
+}
+
+#ifndef DISABLE_PV3DVIEWER
+
+/*!
+ Gets list of selected data owners.(output \a aList).
+*/
+void LightApp_PV3DSelector::getSelection( SUIT_DataOwnerPtrList& aList ) const
+{
+ DBG_FUN();
+
+ if ( !myViewer )
+ return;
+
+ if ( !myViewer->isSelectionEnabled() )
+ return;
+
+ // if(SUIT_ViewManager* aViewManager = myViewer->getViewManager()){
+ // if(PV3DViewer_ViewManager* aViewMgr = dynamic_cast<PV3DViewer_ViewManager*>(aViewManager)){
+ // if(PV3DViewer_ViewWindow* aView = dynamic_cast<PV3DViewer_ViewWindow*>(aViewMgr->getActiveView())){
+ // if(SPV3D_Selector* aSelector = aView->GetSelector()){
+ // const SALOME_ListIO& aListIO = aSelector->StoredIObjects();
+ // SALOME_ListIteratorOfListIO anIter(aListIO);
+ // for(; anIter.More(); anIter.Next()){
+ // Handle(SALOME_InteractiveObject) anIO = anIter.Value();
+ // if(anIO->hasEntry())
+ // aList.append(new LightApp_SPV3DDataOwner(anIO,aViewMgr->getDesktop()));
+ // }
+ // }
+ // }
+ // }
+ // }
+}
+
+/*!
+ Sets selection to selector from data owner list \a theList.
+*/
+void LightApp_PV3DSelector::setSelection( const SUIT_DataOwnerPtrList& theList )
+{
+ DBG_FUN();
+
+ if ( myViewer && ( theList.isEmpty() || myViewer->isSelectionEnabled() )) {
+ if(SUIT_ViewManager* aViewMgr = myViewer->getViewManager()){
+ if(SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViewMgr->getActiveView())){
+ // if(PV3DViewer_Selector* aSelector = aView->GetSelector()){
+ // SALOME_ListIO anAppendList;
+ // const SALOME_ListIO& aStoredList = aSelector->StoredIObjects();
+ // SUIT_DataOwnerPtrList::const_iterator anIter = theList.begin();
+ // for(; anIter != theList.end(); ++anIter) {
+ // const SUIT_DataOwner* aDataOwner = (*anIter).get();
+ // if(const LightApp_SPV3DDataOwner* anOwner = dynamic_cast<const LightApp_SPV3DDataOwner*>(aDataOwner))
+ // {
+ // MESSAGE("aSelector->SetSelectionMode("<<anOwner->GetMode()<<");");
+ // aSelector->SetSelectionMode(anOwner->GetMode());
+ // Handle(SALOME_InteractiveObject) anIO = anOwner->IO();
+
+ // aSelector->AddIObject(anIO);
+
+ // anAppendList.Append(anIO);
+ // aSelector->AddOrRemoveIndex(anIO,anOwner->GetIds(),false);
+ // }
+ // else if(const LightApp_DataOwner* anOwner = dynamic_cast<const LightApp_DataOwner*>(aDataOwner))
+ // {
+ // Handle(SALOME_InteractiveObject) anIO =
+ // new SALOME_InteractiveObject(anOwner->entry().toUtf8(),"");
+ // aSelector->AddIObject(anIO);
+ // anAppendList.Append(anIO);
+ // }
+ // }
+ // // To remove IOs, which is not selected.
+ // QMap< QString, Handle( SALOME_InteractiveObject )> toRemove;
+ // SALOME_ListIteratorOfListIO anIt( aStoredList );
+ // for( ; anIt.More(); anIt.Next() )
+ // if( !anIt.Value().IsNull() )
+ // toRemove[ anIt.Value()->getEntry() ] = anIt.Value();
+
+ // anIt = SALOME_ListIteratorOfListIO(anAppendList);
+ // for( ; anIt.More(); anIt.Next() )
+ // toRemove.remove( anIt.Value()->getEntry() );
+
+ // QMap< QString, Handle( SALOME_InteractiveObject )>::const_iterator RIt = toRemove.begin(),
+ // REnd = toRemove.end();
+ // for( ; RIt!=REnd; RIt++ )
+ // aSelector->RemoveIObject( RIt.value() );
+
+ // aView->onSelectionChanged();
+ // }
+ }
+ }
+ }
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef LIGHTAPP_PV3DSELECTOR_H
+#define LIGHTAPP_PV3DSELECTOR_H
+
+#include "LightApp.h"
+
+#include <SUIT_Selector.h>
+#include <SUIT_DataOwner.h>
+
+#include <QObject>
+
+
+#ifndef DISABLE_PV3DVIEWER
+#ifndef DISABLE_SALOMEOBJECT
+ #include "SALOME_InteractiveObject.hxx"
+#endif
+ class SPV3D_ViewModel;
+#endif
+
+
+/*!
+ \class LightApp_PV3DSelector
+ Custom selector to get/set selection from PV3D viewer
+*/
+class LIGHTAPP_EXPORT LightApp_PV3DSelector : public QObject, public SUIT_Selector
+{
+ Q_OBJECT
+
+public:
+ virtual ~LightApp_PV3DSelector() {};
+#ifndef DISABLE_PV3DVIEWER
+ LightApp_PV3DSelector( SPV3D_ViewModel*, SUIT_SelectionMgr* );
+
+ SPV3D_ViewModel* viewer() const;
+
+ virtual QString type() const;
+#else
+ LightApp_PV3DSelector( SUIT_SelectionMgr* );
+#endif
+
+private slots:
+ void onSelectionChanged();
+
+#ifndef DISABLE_PV3DVIEWER
+protected:
+ virtual void getSelection( SUIT_DataOwnerPtrList& ) const;
+ virtual void setSelection( const SUIT_DataOwnerPtrList& );
+
+private:
+ SPV3D_ViewModel* myViewer;
+
+#endif
+};
+
+#endif
myTimeStamp = QTime::currentTime();
+ MSGEL("-----> emit currentSelectionChanged <-----");
emit currentSelectionChanged();
}
bool append = false;
setSelected( remainsOwners, append );
+ MSGEL("-----> emit currentSelectionChanged <-----");
emit currentSelectionChanged();
// Bug 17269: To avoid calling of selected(aList)
<source>NEW_WINDOW_7</source>
<translation>P&ython view</translation>
</message>
+ <message>
+ <source>NEW_WINDOW_8</source>
+ <translation>ParaView&3D view</translation>
+ </message>
<message>
<source>CREATING_NEW_WINDOW</source>
<translation>Create new %1</translation>
{
if (!aHasShift) {
myAISContext->ClearCurrents( false ); // todo: ClearCurrents is deprecated
+ MSGEL("-----> emit deselection <-----");
emit deselection();
}
if ( !isPreselectionEnabled() ) {
myAISContext->ShiftSelect( Standard_True );
else
myAISContext->Select( Standard_True );
+ MSGEL("-----> emit selectionChanged <-----");
emit selectionChanged();
}
case Qt::Key_S:
if (!aHasShift) {
myAISContext->ClearCurrents( false ); // todo: ClearCurrents is deprecated
+ MSGEL("-----> emit deselection <-----");
emit deselection();
}
else
myAISContext->Select( Standard_True );
+ MSGEL("-----> emit selectionChanged <-----");
emit selectionChanged();
break;
*/
void OCCViewer_Viewer::performSelectionChanged()
{
+ MSGEL("-----> emit selectionChanged <-----");
emit selectionChanged();
}
return true;
case QEvent::MouseButtonDblClick:
+ MSGEL("-----> emit mouseDoubleClicked <-----");
emit mouseDoubleClicked(this, (QMouseEvent*)e);
return true;
}
}
else {
+ MSGEL("-----> emit vpTransformationStarted(ZOOMVIEW) <-----");
emit vpTransformationStarted ( ZOOMVIEW );
myViewPort->startZoomAtPoint( aEvent->x(), aEvent->y() );
double delta = (double)( aEvent->delta() ) / ( 15 * 8 );
int x1 = (int)( aEvent->x() + width()*delta/100 );
int y1 = (int)( aEvent->y() + height()*delta/100 );
myViewPort->zoom( x, y, x1, y1 );
+ MSGEL("-----> emit vpTransformationFinished(ZOOMVIEW) <-----");
emit vpTransformationFinished ( ZOOMVIEW );
}
}
{
QContextMenuEvent * aEvent = (QContextMenuEvent*)e;
if ( aEvent->reason() != QContextMenuEvent::Mouse )
+ MSGEL("-----> emit contextMenuRequest <-----");
emit contextMenuRequested( aEvent );
}
return true;
void OCCViewer_ViewWindow::showEvent( QShowEvent* theEvent )
{
DBG_FUN();
+ MSGEL("-----> emit Show <-----");
emit Show( theEvent );
}
void OCCViewer_ViewWindow::hideEvent( QHideEvent* theEvent )
{
DBG_FUN();
+ MSGEL("-----> emit Hide <-----");
emit Hide( theEvent );
}
anAction->setStatusTip( tr( "DSC_MINIMIZE_VIEW" ) );
if ( anAction2 && my2dMode != No2dMode ) toolMgr()->show( ReturnTo3dViewId );
if (toSendSignal) {
+ MSGEL("-----> emit maximized(true) <-----");
emit maximized( this, true );
}
}
anAction->setStatusTip( tr( "DSC_MAXIMIZE_VIEW" ) );
if ( anAction2 && my2dMode != No2dMode ) toolMgr()->hide( ReturnTo3dViewId );
if (toSendSignal) {
+ MSGEL("-----> emit maximized(false) <-----");
emit maximized( this, false );
}
}
--- /dev/null
+# Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# Install ParaView filters, etc ...
+ADD_SUBDIRECTORY(resources)
+
+INCLUDE(UseQtExt)
+
+# --- options ---
+
+INCLUDE_DIRECTORIES(
+ ${PROJECT_SOURCE_DIR}/src/Qtx
+ ${PROJECT_SOURCE_DIR}/src/SUIT
+ ${PROJECT_SOURCE_DIR}/src/PV3DViewer
+ ${PROJECT_SOURCE_DIR}/src/PVViewer
+ ${PROJECT_SOURCE_DIR}/src/PVServerService
+ )
+
+ADD_DEFINITIONS(
+ ${KERNEL_DEFINITIONS}
+ ${PYTHON_DEFINITIONS}
+ )
+
+SET(_link_LIBRARIES
+ ${KERNEL_SALOMELocalTrace}
+ ${KERNEL_OpUtil}
+ suit
+ PV3DViewer
+ PVViewer
+ PVServerService
+ ParaView::pqApplicationComponents
+ ParaView::pqPython
+ )
+
+# --- headers ---
+
+# header files / to be processed by moc
+SET(_moc_HEADERS
+ PV3DViewer_ViewManager.h
+ PV3DViewer_ViewModel.h
+ PV3DViewer_ViewWindow.h
+ # PV3DViewer_Behaviors.h
+ # PV3DViewer_GUIElements.h
+ # PV3DViewer_InitSingleton.h
+)
+
+# header files / no moc processing
+SET(_other_HEADERS
+ PV3DViewer.h
+ # PV3DViewer_OutputWindow.h
+ # PV3DViewer_Core.h
+)
+# header files / to install
+SET(PV3DViewer_HEADERS ${_moc_HEADERS} ${_other_HEADERS})
+
+# resource files / to be processed by lrelease
+SET(_ts_RESOURCES
+ resources/PV3DViewer_msg_en.ts
+ resources/PV3DViewer_msg_ja.ts
+ resources/PV3DViewer_msg_fr.ts
+)
+
+# --- sources ---
+
+# sources / moc wrappings
+QT_WRAP_MOC(_moc_SOURCES ${_moc_HEADERS})
+
+# sources / rcc wrappings
+QT_ADD_RESOURCES(_rcc_SOURCES ${_rcc_RESOURCES})
+
+# sources / static
+SET(_other_SOURCES
+ PV3DViewer_ViewManager.cxx
+ PV3DViewer_ViewModel.cxx
+ PV3DViewer_ViewWindow.cxx
+ # PV3DViewer_OutputWindow.cxx
+ # PV3DViewer_Behaviors.cxx
+ # PV3DViewer_GUIElements.cxx
+ # PV3DViewer_Core.cxx
+ # PV3DViewer_InitSingleton.cxx
+ )
+
+# sources / to compile
+SET(PV3DViewer_SOURCES
+ ${_other_SOURCES}
+ ${_moc_SOURCES}
+ ${_rcc_SOURCES}
+ )
+
+# --- rules ---
+ADD_LIBRARY(PV3DViewer ${PV3DViewer_SOURCES})
+
+TARGET_LINK_LIBRARIES(PV3DViewer ${_link_LIBRARIES})
+INSTALL(TARGETS PV3DViewer EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+
+QT_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_GUI_INSTALL_RES_DATA}")
+
+# --- header and resources installation ---
+INSTALL(FILES ${PV3DViewer_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef PV3DVIEWER_H
+#define PV3DVIEWER_H
+
+#ifdef WIN32
+# if defined PV3DVIEWER_EXPORTS || defined PV3DViewer_EXPORTS
+# define PV3DVIEWER_EXPORT __declspec(dllexport)
+# else
+# define PV3DVIEWER_EXPORT __declspec(dllimport)
+# endif
+#else
+# define PV3DVIEWER_EXPORT
+#endif
+
+#endif // PV3DVIEWER_H
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "PV3DViewer_ViewManager.h"
+#include "PV3DViewer_ViewWindow.h"
+#include "PV3DViewer_ViewModel.h"
+// #include "PV3DViewer_Core.h"
+#include "PVViewer_InitSingleton.h"
+#include "PVViewer_GUIElements.h"
+#include "PVServer_ServiceWrapper.h"
+
+#include <utilities.h>
+
+#include "SUIT_Desktop.h"
+#include "SUIT_Study.h"
+#include "SUIT_Session.h"
+#include "SUIT_MessageBox.h"
+#include "SUIT_ResourceMgr.h"
+
+#include <pqServer.h>
+#include <pqServerConnectReaction.h>
+#include <pqActiveObjects.h>
+
+//---------------------------------------------------------
+#define USE_DEBUG
+//#define MB_IGNORE_QT
+#define MBCLASSNAME "PV3DViewer_ViewManager"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+/*!
+ Constructor
+*/
+PV3DViewer_ViewManager::PV3DViewer_ViewManager(SUIT_Study* study, SUIT_Desktop* desktop)
+: SUIT_ViewManager( study, desktop, new PV3DViewer_ViewModel() )
+{
+ DBG_FUN();
+ MESSAGE("PV3DViewer - view manager created ...");
+ setTitle( tr( "PARAVIEW3D_VIEW_TITLE" ) );
+
+ // Initialize minimal paraview stuff (if not already done)
+ PVViewer_InitSingleton::Init(desktop);
+
+ connect( desktop, SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
+ this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ) );
+}
+
+/*!Enable toolbars if view \a view is ParaView viewer and disable otherwise.
+*/
+void PV3DViewer_ViewManager::onWindowActivated(SUIT_ViewWindow* view)
+{
+ DBG_FUN();
+ if (view)
+ {
+ PV3DViewer_ViewWindow* pvWindow = dynamic_cast<PV3DViewer_ViewWindow*>(view);
+ PVViewer_GUIElements * guiElements = PVViewer_GUIElements::GetInstance( myDesktop );
+ guiElements->setToolBarEnabled(pvWindow!=0);
+ }
+}
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef PV3DVIEWER_VIEWMANAGER_H
+#define PV3DVIEWER_VIEWMANAGER_H
+
+#include "PV3DViewer.h"
+
+#include "SUIT_ViewManager.h"
+
+class SUIT_Desktop;
+class SUIT_Study;
+class SUIT_ViewWindow;
+class PVServer_ServiceWrapper;
+class QMainWindow;
+
+class PV3DVIEWER_EXPORT PV3DViewer_ViewManager : public SUIT_ViewManager
+{
+ Q_OBJECT
+
+public:
+ PV3DViewer_ViewManager(SUIT_Study*, SUIT_Desktop*);
+ ~PV3DViewer_ViewManager() {}
+
+protected slots:
+ void onWindowActivated(SUIT_ViewWindow*);
+};
+
+#endif // PV3DVIEWER_VIEWMANAGER_H
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "PV3DViewer_ViewModel.h"
+#include "PV3DViewer_ViewWindow.h"
+
+#include <utilities.h>
+#include "SUIT_Desktop.h"
+
+//---------------------------------------------------------
+#define USE_DEBUG
+//#define MB_IGNORE_QT
+#define MBCLASSNAME "PV3DViewer_ViewModel"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+//----------------------------------------
+PV3DViewer_ViewModel::PV3DViewer_ViewModel()
+:SUIT_ViewModel()
+{
+ DBG_FUN();
+ MESSAGE("PV3DViewer_ViewModel: creating view model ...");
+}
+
+/*!
+ Create new instance of view window on desktop \a theDesktop.
+ \retval SUIT_ViewWindow* - created view window pointer.
+*/
+SUIT_ViewWindow* PV3DViewer_ViewModel::createView(SUIT_Desktop* desktop)
+{
+ DBG_FUN();
+ return new PV3DViewer_ViewWindow(desktop, this);
+}
+
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef PV3DVIEWER_VIEWMODEL_H
+#define PV3DVIEWER_VIEWMODEL_H
+
+#include "PV3DViewer.h"
+
+#include "SUIT_ViewModel.h"
+
+class SUIT_ViewWindow;
+class SUIT_Desktop;
+class SUIT_Desktop;
+
+class PV3DVIEWER_EXPORT PV3DViewer_ViewModel : public SUIT_ViewModel
+{
+ Q_OBJECT
+
+public:
+ PV3DViewer_ViewModel();
+ virtual ~PV3DViewer_ViewModel() {}
+
+ virtual SUIT_ViewWindow* createView(SUIT_Desktop*);
+ virtual QString getType() const { return Type(); }
+ static QString Type() { return "ParaView3D"; }
+};
+
+#endif // PV3DVIEWER_VIEWMODEL_H
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "PV3DViewer_ViewWindow.h"
+//#include "PV3DViewer_Core.h"
+//#include "PV3DViewer_GUIElements.h"
+#include "PV3DViewer_ViewModel.h"
+#include "PV3DViewer_ViewManager.h"
+
+#include "SUIT_ViewManager.h"
+#include "SUIT_ResourceMgr.h"
+#include "SUIT_Session.h"
+#include "SUIT_Desktop.h"
+#include "SUIT_Application.h"
+
+#include <pqTabbedMultiViewWidget.h>
+#include <pqApplicationCore.h>
+
+//---------------------------------------------------------
+#define USE_DEBUG
+//#define MB_IGNORE_QT
+#define MBCLASSNAME "PV3DViewer_ViewWindow"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+
+/*!
+ \class PV3DViewer_ViewWindow
+ \brief PVGUI view window.
+*/
+
+/*!
+ \brief Constructor.
+ \param theDesktop parent desktop window
+ \param theModel view model
+*/
+PV3DViewer_ViewWindow::PV3DViewer_ViewWindow( SUIT_Desktop* theDesktop, PV3DViewer_ViewModel* theModel )
+ : SUIT_ViewWindow( theDesktop ), myPVMgr( 0 )
+{
+ DBG_FUN();
+ myDesktop = theDesktop;
+ myModel = theModel;
+ setViewManager(myModel->getViewManager());
+ myPVMgr = qobject_cast<pqTabbedMultiViewWidget*>(pqApplicationCore::instance()->manager("MULTIVIEW_WIDGET"));
+ if (myPVMgr) {
+ SUIT_Application* app = SUIT_Session::session()->activeApplication();
+ if ( app )
+ app->addPostRoutine(&PV3DViewer_ViewWindow::removePVMgr);
+ myPVMgr->setParent( this );
+ // This is mandatory, see setParent() method in Qt 4 documentation
+ myPVMgr->show();
+ setCentralWidget( myPVMgr );
+ // Hide toolbars
+ //myPVMgr->hideDecorations(); // MBS:???
+ // PV3DViewer_GUIElements * pvge = PV3DViewer_GUIElements::GetInstance(myDesktop);
+ // pvge->setToolBarVisible(false);
+ } else
+ qDebug("No multiViewManager defined");
+}
+
+/*!
+ \brief Destructor.
+ As pqViewManager persists through the whole session,
+ the destructor first removes it from the children of this PV3DViewer_ViewWindow
+ to prevent its unexpected deletion.
+*/
+PV3DViewer_ViewWindow::~PV3DViewer_ViewWindow()
+{
+ DBG_FUN();
+ if ( myPVMgr ) {
+ // Hide toolbars
+ // PV3DViewer_GUIElements * pvge = PV3DViewer_GUIElements::GetInstance(myDesktop);
+ // pvge->setToolBarEnabled(false);
+ myPVMgr->setParent( 0 );
+ myPVMgr->hide();
+ myPVMgr = 0;
+ setCentralWidget( 0 );
+ }
+}
+
+void PV3DViewer_ViewWindow::removePVMgr()
+{
+ DBG_FUNC();
+ pqTabbedMultiViewWidget* aPVMgr = qobject_cast<pqTabbedMultiViewWidget*>(pqApplicationCore::instance()->manager("MULTIVIEW_WIDGET"));
+ delete aPVMgr;
+}
+
+#if 0
+/*!
+ \brief Get the visual parameters of the view window.
+ \return visual parameters of this view window formatted to the string
+*/
+QString PV3DViewer_ViewWindow::getVisualParameters()
+{
+ return SUIT_ViewWindow::getVisualParameters();
+}
+
+/*!
+ \brief Restore visual parameters of the view window from the formated string
+ \param parameters view window visual parameters
+*/
+void PV3DViewer_ViewWindow::setVisualParameters( const QString& parameters )
+{
+ SUIT_ViewWindow::setVisualParameters( parameters );
+}
+#endif
+
+/*!
+ \brief Returns the ParaView multi-view manager previously set with setPVManager()
+*/
+pqTabbedMultiViewWidget* PV3DViewer_ViewWindow::getMultiViewManager() const
+{
+ DBG_FUN();
+ return myPVMgr;
+}
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef PV3DVIEWER_VIEWWINDOW_H
+#define PV3DVIEWER_VIEWWINDOW_H
+
+#include "PV3DViewer.h"
+
+#include "SUIT_ViewWindow.h"
+#include <QMap>
+
+class SUIT_Desktop;
+class PV3DViewer_ViewModel;
+class pqTabbedMultiViewWidget;
+
+class PV3DVIEWER_EXPORT PV3DViewer_ViewWindow : public SUIT_ViewWindow
+{
+ Q_OBJECT
+
+public:
+ PV3DViewer_ViewWindow( SUIT_Desktop*, PV3DViewer_ViewModel* );
+ virtual ~PV3DViewer_ViewWindow();
+
+ // virtual QString getVisualParameters();
+ // virtual void setVisualParameters( const QString& );
+
+ //virtual void Repaint(bool theUpdateTrihedron = true);
+
+ pqTabbedMultiViewWidget* getMultiViewManager() const;
+
+ static void removePVMgr();
+
+private:
+ SUIT_Desktop* myDesktop;
+ PV3DViewer_ViewModel* myModel;
+ pqTabbedMultiViewWidget* myPVMgr;
+};
+
+#endif // PV3DVIEWER_VIEWWINDOW_H
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// Author: Adrien Bruneton (CEA)
+
+#include "PVViewer_Behaviors.h"
+
+#include <QMainWindow>
+
+#include <pqInterfaceTracker.h>
+#include <pqApplicationCore.h>
+#include <pqPluginManager.h>
+#include <pqStandardPropertyWidgetInterface.h>
+#include <pqStandardViewFrameActionsImplementation.h>
+#include <pqPropertiesPanel.h>
+
+#include <pqAlwaysConnectedBehavior.h>
+#include <pqAutoLoadPluginXMLBehavior.h>
+#include <pqCommandLineOptionsBehavior.h>
+#include <pqCrashRecoveryBehavior.h>
+#include <pqDataTimeStepBehavior.h>
+#include <pqDefaultViewBehavior.h>
+#include <pqObjectPickingBehavior.h>
+#include <pqPipelineContextMenuBehavior.h>
+#include <pqPluginActionGroupBehavior.h>
+#include <pqPluginDockWidgetsBehavior.h>
+#include <pqSpreadSheetVisibilityBehavior.h>
+#include <pqUndoRedoBehavior.h>
+#include <pqViewStreamingBehavior.h>
+#include <pqCollaborationBehavior.h>
+#include <pqVerifyRequiredPluginBehavior.h>
+#include <pqPluginSettingsBehavior.h>
+#include <pqApplyBehavior.h>
+
+#include <pqPropertiesPanel.h>
+
+int PVViewer_Behaviors::BehaviorLoadingLevel = 0;
+
+PVViewer_Behaviors::PVViewer_Behaviors(QMainWindow * parent)
+ : QObject(parent)
+{
+}
+
+/**! Instanciate minimal ParaView behaviors needed when using an instance of PVViewer.
+ * This method should be updated at each new version of ParaView with what is found in
+ * Qt/ApplicationComponents/pqParaViewBehaviors.cxx
+ */
+void PVViewer_Behaviors::instanciateMinimalBehaviors(QMainWindow * /*desk*/)
+{
+ if (BehaviorLoadingLevel < 1)
+ {
+ // Register ParaView interfaces.
+ pqInterfaceTracker* pgm = pqApplicationCore::instance()->interfaceTracker();
+
+ // Register standard types of property widgets.
+ pgm->addInterface(new pqStandardPropertyWidgetInterface(pgm));
+ // Register standard types of view-frame actions.
+ pgm->addInterface(new pqStandardViewFrameActionsImplementation(pgm));
+
+ new pqPipelineContextMenuBehavior(this);
+ new pqDefaultViewBehavior(this); // shows a 3D view as soon as a server connection is made
+ new pqAlwaysConnectedBehavior(this); // client always connected to a server
+ new pqVerifyRequiredPluginBehavior(this);
+ new pqPluginSettingsBehavior(this);
+ new pqCrashRecoveryBehavior(this);
+ new pqCommandLineOptionsBehavior(this);
+
+ BehaviorLoadingLevel = 1;
+ }
+}
+
+/**! Instanciate usual ParaView behaviors.
+ * This method should be updated at each new version of ParaView with what is found in
+ * Qt/ApplicationComponents/pqParaViewBehaviors.cxx
+ */
+void PVViewer_Behaviors::instanciateAllBehaviors(QMainWindow * desk)
+{
+ // "new pqParaViewBehaviors(anApp->desktop(), this);"
+ // -> (which loads all standard ParaView behaviors at once) has to be replaced in order to
+ // exclude using of pqQtMessageHandlerBehaviour
+
+ // Define application behaviors.
+ if (BehaviorLoadingLevel < 1)
+ instanciateMinimalBehaviors(desk);
+
+ if (BehaviorLoadingLevel < 2)
+ {
+ //new pqQtMessageHandlerBehavior(this); // THIS ONE TO EXCLUDE !! see comment above
+ new pqDataTimeStepBehavior(this);
+ new pqSpreadSheetVisibilityBehavior(this);
+ //new pqPipelineContextMenuBehavior(this);
+ new pqUndoRedoBehavior(this);
+ new pqAutoLoadPluginXMLBehavior(this); // auto load plugins GUI stuff
+ new pqPluginDockWidgetsBehavior(desk);
+ new pqPluginActionGroupBehavior(desk);
+ // rnv: Disable ParaView main window persistance mechanism,
+ // because SALOME has own functionality for store/restore windows state.
+ // new pqPersistentMainWindowStateBehavior(desk);
+ new pqObjectPickingBehavior(desk);
+ new pqCollaborationBehavior(this);
+ new pqViewStreamingBehavior(this);
+
+ // Move instantiation of the pqApplyBehavior to the PVViewer_GUIElements::buildPVWidgets(),
+ // because without pqPropertiesPanel it doesn't make sense.
+ /*
+ pqApplyBehavior* applyBehavior = new pqApplyBehavior(this);
+ foreach (pqPropertiesPanel* ppanel, desk->findChildren<pqPropertiesPanel*>())
+ {
+ applyBehavior->registerPanel(ppanel);
+ }
+ */
+ BehaviorLoadingLevel = 2;
+ }
+}
--- /dev/null
+// Copyright (C) 2014-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// Author: Adrien Bruneton (CEA)
+
+
+#ifndef PVVIEWER_BEHAVIORS_H
+#define PVVIEWER_BEHAVIORS_H
+
+#include "PVViewer.h"
+
+#include <QObject>
+
+class QMainWindow;
+class pqPropertiesPanel;
+
+/**!
+ * PARAVIS behaviors - mimic what is done in
+ * Qt/ApplicationComponents/pqParaViewBehaviors.cxx
+ * Except a few ones, behaviors are destroyed when the module is destroyed.
+ */
+class PVVIEWER_EXPORT PVViewer_Behaviors: public QObject
+{
+ Q_OBJECT
+
+public:
+ PVViewer_Behaviors(QMainWindow*);
+
+ void instanciateMinimalBehaviors(QMainWindow*);
+ void instanciateAllBehaviors(QMainWindow*);
+
+ virtual ~PVViewer_Behaviors() {}
+
+private:
+ static int BehaviorLoadingLevel;
+};
+
+#endif // PVVIEWER_BEHAVIORS_H
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.0" language="en_US">
+<context>
+ <name>@default</name>
+ <message>
+ </message>
+</context>
+<context>
+ <name>PV3DViewer_ViewManager</name>
+ <message>
+ <source>PARAVIEW3D_VIEW_TITLE</source>
+ <translation>ParaView3D scene:%M - viewer:%V</translation>
+ </message>
+</context>
+</TS>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.0" language="fr_FR">
+<context>
+ <name>@default</name>
+ <message>
+ </message>
+</context>
+<context>
+ <name>PV3DViewer_ViewManager</name>
+ <message>
+ <source>PARAVIEW3D_VIEW_TITLE</source>
+ <translation>Scène ParaView3D:%M - visualiseur:%V</translation>
+ </message>
+</context>
+</TS>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.0" language="ja" sourcelanguage="en">
+ <context>
+ <name>@default</name>
+ <message>
+ <translation type="unfinished"/>
+ </message>
+ </context>
+ <context>
+ <name>PV3DViewer_ViewManager</name>
+ <message>
+ <source>PARAVIEW3D_VIEW_TITLE</source>
+ <translation>ParaView3D シーン:%M - ビューア:%V</translation>
+ </message>
+ </context>
+</TS>
// base implementation does nothing
}
+#undef MBCLASSNAME
#define MBCLASSNAME "SALOME_OCCPrs"
/*!
Dispatches display operation to proper Display() method of SALOME_View
if ( d ) d->Update( this );
}
+#undef MBCLASSNAME
#define MBCLASSNAME "SALOME_VTKPrs"
/*!
Dispatches display operation to proper Display() method of SALOME_View
if ( d ) d->Update( this );
}
+#undef MBCLASSNAME
+#define MBCLASSNAME "SALOME_PV3DPrs"
+/*!
+ Dispatches display operation to proper Display() method of SALOME_View
+*/
+void SALOME_PV3DPrs::DisplayIn( SALOME_View* v ) const
+{
+ DBG_FUN();
+ if ( v ) v->Display( this );
+}
+
+/*!
+ Dispatches display operation to proper Erase() method of SALOME_View
+*/
+void SALOME_PV3DPrs::EraseIn( SALOME_View* v, const bool forced ) const
+{
+ DBG_FUN();
+ if ( v ) v->Erase( this, forced );
+}
+
+/*!
+ Dispatches display operation to proper BeforeDisplay() method of SALOME_Displayer
+*/
+void SALOME_PV3DPrs::BeforeDisplayIn( SALOME_Displayer* d, SALOME_View* v ) const
+{
+ DBG_FUN();
+ d->BeforeDisplay( v, this );
+}
+
+/*!
+ Dispatches display operation to proper AfterDisplay() method of SALOME_Displayer
+*/
+void SALOME_PV3DPrs::AfterDisplayIn( SALOME_Displayer* d, SALOME_View* v ) const
+{
+ DBG_FUN();
+ d->AfterDisplay( v, this );
+}
+
+/*!
+ Dispatches display operation to proper BeforeErase() method of SALOME_Displayer
+*/
+void SALOME_PV3DPrs::BeforeEraseIn( SALOME_Displayer* d, SALOME_View* v ) const
+{
+ DBG_FUN();
+ d->BeforeErase( v, this );
+}
+
+/*!
+ Dispatches display operation to proper AfterErase() method of SALOME_Displayer
+*/
+void SALOME_PV3DPrs::AfterEraseIn( SALOME_Displayer* d, SALOME_View* v ) const
+{
+ DBG_FUN();
+ d->AfterErase( v, this );
+}
+
+/*!
+ Dispatches operation to proper LocalSelectionIn() method of SALOME_View
+*/
+void SALOME_PV3DPrs::LocalSelectionIn( SALOME_View* v, const int mode ) const
+{
+ DBG_FUN();
+ std::list<int> modes;
+ modes.push_back( mode );
+ LocalSelectionIn( v, modes );
+}
+
+/*!
+ Dispatches operation to proper LocalSelectionIn() method of SALOME_View
+*/
+void SALOME_PV3DPrs::LocalSelectionIn( SALOME_View* v, const std::list<int> modes ) const
+{
+ DBG_FUN();
+ if ( v && !modes.empty() ) v->LocalSelection( this, modes );
+}
+
+/*!
+ Dispatches update operation to proper Update() method of SALOME_Displayer
+*/
+void SALOME_PV3DPrs::Update( SALOME_Displayer* d )
+{
+ DBG_FUN();
+ if ( d ) d->Update( this );
+}
+
+#undef MBCLASSNAME
#define MBCLASSNAME "SALOME_Prs2d"
/*!
Dispatches display operation to proper Display() method of SALOME_View
// MESSAGE( "SALOME_View::Display( const SALOME_VTKPrs& ) called! Probably, presentation is being displayed in uncompatible viewframe." );
}
+//MBS:
+/*!
+ Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
+*/
+void SALOME_View::Display( const SALOME_PV3DPrs* )
+{
+ MSGEL("...SALOME_View::Display(SALOME_PV3DPrs)");
+// MESSAGE( "SALOME_View::Display( const SALOME_PV3DPrs& ) called! Probably, presentation is being displayed in uncompatible viewframe." );
+}
+
/*!
Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
*/
// MESSAGE( "SALOME_View::Erase( const SALOME_VTKPrs& ) called! Probably, presentation is being erased in uncompatible viewframe." );
}
+//MBS:
+/*!
+ Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
+*/
+void SALOME_View::Erase( const SALOME_PV3DPrs*, const bool )
+{
+ MSGEL("...SALOME_View::Erase(SALOME_PV3DPrs,bool)");
+// MESSAGE( "SALOME_View::Erase( const SALOME_PV3DPrs& ) called! Probably, presentation is being erased in uncompatible viewframe." );
+}
+
/*!
Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
*/
// Probably, selection is being activated in uncompatible viewframe." );
}
+//MBS:
+/*!
+ Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
+*/
+void SALOME_View::LocalSelection( const SALOME_PV3DPrs*, const int )
+{
+ MSGEL("...SALOME_View::LocalSelection(SALOME_PV3DPrs,int)");
+// MESSAGE( "SALOME_View::LocalSelection( const SALOME_PV3DPrs* ) called!
+// Probably, selection is being activated in uncompatible viewframe." );
+}
+
/*!
Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
*/
p->AfterEraseIn( d, this );
}
+#undef MBCLASSNAME
#define MBCLASSNAME "SALOME_Displayer"
/*!
Gives control to SALOME_Prs object, so that it could perform double dispatch
// MESSAGE( "SALOME_Displayer::Update( SALOME_VTKPrs* ) called! Probably, presentation is being updated in uncompatible viewframe." );
}
+//MBS:
+/*!
+ Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
+*/
+void SALOME_Displayer::Update( SALOME_PV3DPrs* )
+{
+ MSGEL("...SALOME_Displayer::Update(SALOME_PV3DPrs)");
+// MESSAGE( "SALOME_Displayer::Update( SALOME_PV3DPrs* ) called! Probably, presentation is being updated in uncompatible viewframe." );
+}
+
/*!
Virtual method, should be reimplemented in successors, by default issues a warning and does nothing.
*/
virtual void LocalSelectionIn( SALOME_View*, const int ) const;
};
+//MBS:
+/*!
+ \class SALOME_PV3DPrs
+ Base class for PV3D graphic object (pqPipelineSource) wrappers.
+ This intermediate class is necessary to avoid dependencies from ParaView libs.
+*/
+
+class PRS_EXPORT SALOME_PV3DPrs : public SALOME_Prs
+{
+public:
+ //! Constructor
+ explicit SALOME_PV3DPrs(const char* e) : SALOME_Prs(e) {}
+
+ //! It uses double dispatch in order to
+ //! invoke Display() method corresponding to the actual type of presentation.
+ virtual void DisplayIn( SALOME_View* ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke Erase() method corresponding to the actual type of presentation.
+ virtual void EraseIn( SALOME_View*, const bool = false ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke BeforeDisplayIn() method corresponding to the actual type of presentation.
+ virtual void BeforeDisplayIn( SALOME_Displayer*, SALOME_View* ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke AfterDisplayIn() method corresponding to the actual type of presentation.
+ virtual void AfterDisplayIn( SALOME_Displayer*, SALOME_View* ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke BeforeEraseIn() method corresponding to the actual type of presentation.
+ virtual void BeforeEraseIn( SALOME_Displayer*, SALOME_View* ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke AfterEraseIn() method corresponding to the actual type of presentation.
+ virtual void AfterEraseIn( SALOME_Displayer*, SALOME_View* ) const;
+
+ //! It uses double dispatch in order to
+ //! invoke Update() method corresponding to the actual type of presentation.
+ virtual void Update( SALOME_Displayer* );
+
+ //! Key method for double dispatch of activation of sub-shapes selection
+ virtual void LocalSelectionIn( SALOME_View*, const int ) const;
+ virtual void LocalSelectionIn( SALOME_View*, const std::list<int> ) const;
+};
+
/*!
\class SALOME_Prs2d
Base class for Plot2d graphic object (Plot2d_Curve) wrappers.
// Display() methods for ALL kinds of presentation should appear here
virtual void Display( const SALOME_OCCPrs* );//!< Display SALOME_OCCPrs presentation.
virtual void Display( const SALOME_VTKPrs* );//!< Display SALOME_VTKPrs presentation.
+ virtual void Display( const SALOME_PV3DPrs* );//!< Display SALOME_PV3DPrs presentation. //MBS:
virtual void Display( const SALOME_Prs2d* );//!< Display SALOME_Prs2d presentation.
// Add new Display() methods here...
// Erase() methods for ALL kinds of presentation should appear here
virtual void Erase( const SALOME_OCCPrs*, const bool = false );//!< Erase SALOME_OCCPrs
virtual void Erase( const SALOME_VTKPrs*, const bool = false );//!< Erase SALOME_VTKPrs
+ virtual void Erase( const SALOME_PV3DPrs*, const bool = false );//!< Erase SALOME_PV3DPrs //MBS:
virtual void Erase( const SALOME_Prs2d*, const bool = false );//!< Erase SALOME_Prs2d
// Add new Erase() methods here...
virtual void LocalSelection( const SALOME_OCCPrs*, const int ); //!< Local selection SALOME_OCCPrs
virtual void LocalSelection( const SALOME_OCCPrs*, const std::list<int> );//!< Multiple local selection SALOME_OCCPrs
virtual void LocalSelection( const SALOME_VTKPrs*, const int ); //!< Local selection SALOME_VTKPrs
+ virtual void LocalSelection( const SALOME_PV3DPrs*, const int ); //!< Local selection SALOME_PV3DPrs //MBS:
virtual void LocalSelection( const SALOME_Prs2d* , const int ); //!< Local selection SALOME_Prs2d
//! Deactivates selection of sub-shapes (must be redefined with OCC viewer)
virtual void GlobalSelection( const bool = false ) const;
- //! Creates empty presenation of corresponding type
+ //! Creates empty presentation of corresponding type
virtual SALOME_Prs* CreatePrs( const char* /*entry*/ = 0 ) { return 0; }
// Axiluary methods called before and after displaying of objects
// Update() methods for ALL kinds of presentation should appear here
virtual void Update( SALOME_OCCPrs* );//!< Update SALOME_OCCPrs presentation.
virtual void Update( SALOME_VTKPrs* );//!< Update SALOME_VTKPrs presentation.
+ virtual void Update( SALOME_PV3DPrs* );//!< Update SALOME_PV3DPrs presentation.//MBS:
virtual void Update( SALOME_Prs2d* );//!< Update SALOME_Prs2d presentation.
// Add new Update() methods here...
virtual void AfterDisplay ( SALOME_View*, const SALOME_OCCPrs* ) {} //! Null body here
virtual void BeforeDisplay( SALOME_View*, const SALOME_VTKPrs* ) {} //! Null body here
virtual void AfterDisplay ( SALOME_View*, const SALOME_VTKPrs* ) {} //! Null body here
+ virtual void BeforeDisplay( SALOME_View*, const SALOME_PV3DPrs* ) {} //! Null body here //MBS:
+ virtual void AfterDisplay ( SALOME_View*, const SALOME_PV3DPrs* ) {} //! Null body here //MBS:
virtual void BeforeDisplay( SALOME_View*, const SALOME_Prs2d* ) {} //! Null body here
virtual void AfterDisplay ( SALOME_View*, const SALOME_Prs2d* ) {} //! Null body here
virtual void AfterErase ( SALOME_View*, const SALOME_OCCPrs* ) {} //! Null body here
virtual void BeforeErase( SALOME_View*, const SALOME_VTKPrs* ) {} //! Null body here
virtual void AfterErase ( SALOME_View*, const SALOME_VTKPrs* ) {} //! Null body here
+ virtual void BeforeErase( SALOME_View*, const SALOME_PV3DPrs* ) {} //! Null body here //MBS:
+ virtual void AfterErase ( SALOME_View*, const SALOME_PV3DPrs* ) {} //! Null body here //MBS:
virtual void BeforeErase( SALOME_View*, const SALOME_Prs2d* ) {} //! Null body here
virtual void AfterErase ( SALOME_View*, const SALOME_Prs2d* ) {} //! Null body here
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/VTKViewer)
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/SVTK)
ENDIF()
+IF(SALOME_USE_PV3DVIEWER)
+ INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/PV3DViewer)
+ INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/SPV3D)
+ENDIF()
IF(SALOME_USE_PVVIEWER)
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/PVViewer)
ENDIF(SALOME_USE_PVVIEWER)
${PROJECT_SOURCE_DIR}/src/LightApp
${PROJECT_SOURCE_DIR}/src/OBJECT
${PROJECT_SOURCE_DIR}/src/OCCViewer
+ ${PROJECT_SOURCE_DIR}/src/PV3DViewer
${PROJECT_SOURCE_DIR}/src/Plot2d
${PROJECT_SOURCE_DIR}/src/Prs
${PROJECT_SOURCE_DIR}/src/Qtx
${PROJECT_SOURCE_DIR}/src/SOCC
+ ${PROJECT_SOURCE_DIR}/src/SPV3D
${PROJECT_SOURCE_DIR}/src/STD
${PROJECT_SOURCE_DIR}/src/SUIT
${PROJECT_SOURCE_DIR}/src/SVTK
--- /dev/null
+# Copyright (C) 2012-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+INCLUDE(UseQtExt)
+
+# --- options ---
+
+# additional include directories
+INCLUDE_DIRECTORIES(
+ ${OpenCASCADE_INCLUDE_DIR}
+ ${QT_INCLUDES}
+ ${Boost_INCLUDE_DIRS}
+ ${PTHREAD_INCLUDE_DIR}
+ ${PROJECT_SOURCE_DIR}/src/Qtx
+ ${PROJECT_SOURCE_DIR}/src/SUIT
+ # ${PROJECT_SOURCE_DIR}/src/ViewerTools
+ ${PROJECT_SOURCE_DIR}/src/OBJECT
+ ${PROJECT_SOURCE_DIR}/src/Prs
+ ${PROJECT_SOURCE_DIR}/src/PV3DViewer
+ ${PROJECT_SOURCE_DIR}/src/PVViewer
+ ${PROJECT_SOURCE_DIR}/src/PVServerService
+)
+ # ${PROJECT_SOURCE_DIR}/src/OpenGLUtils
+
+# additional preprocessor / compiler flags
+ADD_DEFINITIONS(${QT_DEFINITIONS} ${OpenCASCADE_DEFINITIONS} ${BOOST_DEFINITIONS})
+
+# libraries to link to
+SET(_link_LIBRARIES
+ ${QT_LIBRARIES}
+ ${OPENGL_LIBRARIES}
+ ${OpenCASCADE_FoundationClasses_LIBRARIES} ${OpenCASCADE_Visualization_LIBRARIES}
+ ${KERNEL_OpUtil}
+ qtx suit
+ #ViewerTools
+ SalomeObject SalomePrs PV3DViewer PVViewer PVServerService
+ ParaView::pqApplicationComponents
+ ParaView::pqPython
+)
+ #OpenGLUtils
+ # VTK::RenderingAnnotation
+ # VTK::ImagingCore
+ # VTK::CommonSystem
+ # VTK::IOExportGL2PS
+
+# --- headers ---
+
+# header files / to be processed by moc
+SET(_moc_HEADERS
+ SPV3D_ViewManager.h
+ SPV3D_ViewModel.h
+ SPV3D_ViewWindow.h
+ #SPV3D_View.h
+)
+ # SPV3D_ComboAction.h
+ # SPV3D_FontWidget.h
+ # SPV3D_GenericRenderWindowInteractor.h
+ # SPV3D_RecorderDlg.h
+ # SPV3D_PsOptionsDlg.h
+ # SPV3D_RenderWindowInteractor.h
+ # SPV3D_SetRotationPointDlg.h
+ # SPV3D_ViewModelBase.h
+ # SPV3D_ViewParameterDlg.h
+
+# header files / to be processed by moc / internal
+# TODO: check for MSVS project
+# SET(_moc_internal_HEADERS
+# )
+ # SPV3D_CubeAxesDlg.h
+ # SPV3D_NonIsometricDlg.h
+ # SPV3D_UpdateRateDlg.h
+
+# header files / no moc processing
+SET(_other_HEADERS
+ SPV3D.h
+ SPV3D_Prs.h
+ #SALOME_Actor.h
+)
+ # SPV3D_Actor.h
+ # SPV3D_AreaPicker.h
+ # SPV3D_CubeAxesActor2D.h
+ # SPV3D_DeviceActor.h
+ # SPV3D_Event.h
+ # SPV3D_Functor.h
+ # SPV3D_ImageWriter.h
+ # SPV3D_ImageWriterMgr.h
+ # SPV3D_InteractorStyle.h
+ # SPV3D_KeyFreeInteractorStyle.h
+ # SPV3D_Recorder.h
+ # SPV3D_Renderer.h
+ # SPV3D_Selection.h
+ # SPV3D_SelectionEvent.h
+ # SPV3D_Selector.h
+ # SPV3D_SpaceMouse.h
+ # SPV3D_Utils.h
+ # SPV3D_Hash.h
+
+# header files / no moc processing / internal
+# no processing currently: TODO: check for MSVS project
+# SET(_internal_HEADERS
+# # SPV3D_SelectorDef.h
+# # SPV3D_Trihedron.h
+# # SPV3D_AxesActor.h
+# # SPV3D_AxesWidget.h
+# )
+
+# header files / to install
+SET(SPV3D_HEADERS ${_moc_HEADERS} ${_other_HEADERS})
+
+# --- resources ---
+
+# resource files / to be processed by lrelease
+# SET(_ts_RESOURCES
+# resources/SPV3D_msg_en.ts
+# resources/SPV3D_msg_fr.ts
+# resources/SPV3D_msg_ja.ts
+# resources/SPV3D_images.ts
+# )
+
+# resource files / static
+# SET(_other_RESOURCES
+# # resources/vtk_view_graduated_axes.png
+# # resources/vtk_view_highlight.png
+# # resources/vtk_view_highlight_dyn.png
+# # resources/vtk_view_highlight_off.png
+# # resources/vtk_view_highlight_std.png
+# # resources/vtk_view_parallel.png
+# # resources/vtk_view_parameters.png
+# # resources/vtk_view_perspective.png
+# # resources/vtk_view_recording_pause.png
+# # resources/vtk_view_recording_play.png
+# # resources/vtk_view_recording_start.png
+# # resources/vtk_view_recording_stop.png
+# # resources/vtk_view_rotation_point.png
+# # resources/vtk_view_scaling.png
+# # resources/vtk_view_selection.png
+# # resources/vtk_view_stereo.png
+# # resources/vtk_view_style_switch.png
+# # resources/vtk_view_update_rate.png
+# # resources/vtk_view_zooming_style_switch.png
+# )
+
+# --- sources ---
+
+# sources / moc wrappings
+QT_WRAP_MOC(_moc_SOURCES ${_moc_HEADERS} ${_moc_internal_HEADERS})
+
+# sources / static
+SET(_other_SOURCES
+ SPV3D_Prs.cxx
+ SPV3D_ViewManager.cxx
+ SPV3D_ViewModel.cxx
+ SPV3D_ViewWindow.cxx
+ #SPV3D_View.cxx
+ #SALOME_Actor.cxx
+)
+ #SPV3D_Actor.cxx
+ # SPV3D_AreaPicker.cxx
+ # SPV3D_ComboAction.cxx
+ # SPV3D_CubeAxesActor2D.cxx
+ # SPV3D_CubeAxesDlg.cxx
+ # SPV3D_DeviceActor.cxx
+ # SPV3D_FontWidget.cxx
+ # SPV3D_GenericRenderWindowInteractor.cxx
+ # SPV3D_ImageWriter.cxx
+ # SPV3D_ImageWriterMgr.cxx
+ # SPV3D_InteractorStyle.cxx
+ # SPV3D_KeyFreeInteractorStyle.cxx
+ # SPV3D_NonIsometricDlg.cxx
+ # SPV3D_Recorder.cxx
+ # SPV3D_RecorderDlg.cxx
+ # SPV3D_PsOptionsDlg.cxx
+ # SPV3D_RenderWindowInteractor.cxx
+ #SPV3D_Renderer.cxx
+ #SPV3D_Selector.cxx
+ # SPV3D_SetRotationPointDlg.cxx
+ # SPV3D_SpaceMouse.cxx
+ # SPV3D_Trihedron.cxx
+ # SPV3D_UpdateRateDlg.cxx
+ # SPV3D_Utils.cxx
+ #SPV3D_ViewParameterDlg.cxx
+ # SPV3D_AxesActor.cxx
+ # SPV3D_AxesWidget.cxx
+
+# sources / to compile
+SET(SPV3D_SOURCES ${_other_SOURCES} ${_moc_SOURCES})
+
+# --- rules ---
+
+ADD_LIBRARY(SPV3D ${SPV3D_SOURCES})
+TARGET_LINK_LIBRARIES(SPV3D ${_link_LIBRARIES})
+INSTALL(TARGETS SPV3D EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+
+INSTALL(FILES ${SPV3D_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+# QT_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_GUI_INSTALL_RES_DATA}")
+
+INSTALL(FILES ${_other_RESOURCES} DESTINATION ${SALOME_GUI_INSTALL_RES_DATA})
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef SPV3D_H
+#define SPV3D_H
+
+#ifdef WIN32
+# if defined SPV3D_EXPORTS
+# define SPV3D_EXPORT __declspec(dllexport)
+# else
+# define SPV3D_EXPORT __declspec(dllimport)
+# endif
+#else
+# define SPV3D_EXPORT
+#endif
+
+#if defined WIN32
+#pragma warning ( disable: 4251 )
+#pragma warning ( disable: 4786 )
+#endif
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// SALOME PV3DViewer : build PV3D viewer into Salome desktop
+// File : SPV3D_Prs.cxx
+
+#include "SPV3D_Prs.h"
+
+#include <vtkActorCollection.h>
+
+//---------------------------------------------------------
+#define USE_DEBUG
+#define MBCLASSNAME "SPV3D_Prs"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+/*!
+ Default constructor
+*/
+SPV3D_Prs::SPV3D_Prs( const char* entry ) : SALOME_PV3DPrs(entry), myObjects( 0 )
+{
+ DBG_FUN();
+ ARG(entry);
+}
+
+/*!
+ Standard constructor
+*/
+SPV3D_Prs::SPV3D_Prs( const char* entry, const vtkActor* obj ) : SALOME_PV3DPrs(entry)
+{
+ DBG_FUN();
+ ARG(entry);
+ AddObject( obj );
+}
+
+/*!
+ Destructor
+*/
+SPV3D_Prs:: ~SPV3D_Prs()
+{
+ DBG_FUN();
+ if ( myObjects ) myObjects->Delete();
+}
+
+/*!
+ \return actors list
+*/
+vtkActorCollection* SPV3D_Prs::GetObjects() const
+{
+ return myObjects;
+}
+
+/*!
+ Add actor
+*/
+void SPV3D_Prs::AddObject( const vtkActor* obj )
+{
+ DBG_FUN();
+ if ( !myObjects)
+ myObjects = vtkActorCollection::New();
+ myObjects->AddItem( (vtkActor*)obj );
+}
+
+/*!
+ \return 0 if list of the actors is empty [ Reimplemented from SALOME_Prs ]
+*/
+bool SPV3D_Prs::IsNull() const
+{
+ return !myObjects || myObjects->GetNumberOfItems() <= 0;
+}
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// SALOME PV3DViewer : build PV3D viewer into Salome desktop
+// File : SPV3D_Prs.h
+
+#ifndef SPV3D_Prs_H
+#define SPV3D_Prs_H
+
+#include "SPV3D.h"
+#include "SALOME_Prs.h"
+
+class vtkActorCollection;
+class vtkActor;
+
+class SPV3D_EXPORT SPV3D_Prs : public SALOME_PV3DPrs
+{
+public:
+ explicit SPV3D_Prs( const char* entry );
+ // Default constructor
+ SPV3D_Prs( const char* entry, const vtkActor* obj );
+ // Standard constructor
+ ~SPV3D_Prs();
+ // Destructor
+
+ vtkActorCollection* GetObjects() const;
+ // Get actors list
+ void AddObject( const vtkActor* obj );
+ // Add actor
+
+ bool IsNull() const;
+ // Reimplemented from SALOME_Prs
+
+private:
+ vtkActorCollection* myObjects; // list of actors
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "SPV3D_ViewManager.h"
+#include "SPV3D_ViewModel.h"
+#include "SPV3D_ViewWindow.h"
+
+#include <PV3DViewer_ViewManager.h>
+
+#include "PVViewer_InitSingleton.h"
+#include "PVViewer_GUIElements.h"
+#include "PVServer_ServiceWrapper.h"
+
+#include <SUIT_Desktop.h>
+
+//---------------------------------------------------------
+#define USE_DEBUG
+#define MBCLASSNAME "SPV3D_ViewManager"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+/*!
+ Constructor
+*/
+SPV3D_ViewManager::SPV3D_ViewManager( SUIT_Study* study, SUIT_Desktop* theDesktop )
+: SUIT_ViewManager( study, theDesktop, new SPV3D_ViewModel() )
+{
+ DBG_FUN();
+ setTitle( PV3DViewer_ViewManager::tr( "PARAVIEW3D_VIEW_TITLE" ) );
+
+ // Initialize minimal paraview stuff (if not already done)
+ PVViewer_InitSingleton::Init(theDesktop);
+
+ connect( theDesktop, SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
+ this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ) );
+}
+
+/*!
+ Destructor
+*/
+SPV3D_ViewManager::~SPV3D_ViewManager()
+{
+ DBG_FUN();
+}
+
+/*!
+ \return corresponding main window
+*/
+SUIT_Desktop* SPV3D_ViewManager::getDesktop()
+{
+ return myDesktop;
+}
+
+/*!Enable toolbars if view \a view is ParaView viewer and disable otherwise.
+*/
+void SPV3D_ViewManager::onWindowActivated(SUIT_ViewWindow* view)
+{
+ DBG_FUN();
+ if (view)
+ {
+ SPV3D_ViewWindow* pvWindow = dynamic_cast<SPV3D_ViewWindow*>(view);
+ PVViewer_GUIElements * guiElements = PVViewer_GUIElements::GetInstance( myDesktop );
+ guiElements->setToolBarEnabled(pvWindow!=0);
+ }
+}
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef SPV3D_VIEWMANAGER_H
+#define SPV3D_VIEWMANAGER_H
+
+#include "SUIT_ViewManager.h"
+//#include "PV3DViewer_ViewManager.h"
+#include "SPV3D.h"
+
+class SUIT_Desktop;
+class SUIT_Study;
+class SUIT_ViewWindow;
+
+//! Extend SUIT_ViewManager to deal with SPV3D_ViewModel
+class SPV3D_EXPORT SPV3D_ViewManager : public SUIT_ViewManager
+{
+ Q_OBJECT
+
+public:
+ //! Construct the view manager
+ SPV3D_ViewManager( SUIT_Study* study, SUIT_Desktop* );
+
+ //! Destroy the view manager
+ virtual ~SPV3D_ViewManager();
+
+ SUIT_Desktop* getDesktop();
+
+protected slots:
+ void onWindowActivated(SUIT_ViewWindow*);
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include <QMenu>
+#include <QColorDialog>
+#include <QToolBar>
+#include <QTimer>
+
+// #include <vtkCamera.h>
+// #include <vtkRenderer.h>
+#include <vtkActorCollection.h>
+
+//#include "SUIT_Session.h"
+#include "SPV3D_ViewModel.h"
+#include "SPV3D_ViewWindow.h"
+// #include "SPV3D_View.h"
+// #include "SPV3D_Renderer.h"
+//#include "SPV3D_MainWindow.h"
+#include "SPV3D_Prs.h"
+
+// #include "PV3DViewer_Algorithm.h"
+//#include "PV3DViewer_ViewModel.h"
+
+#include "SUIT_ViewModel.h"
+#include "SUIT_ViewManager.h"
+
+//#include "SALOME_Actor.h"
+#include "SALOME_InteractiveObject.hxx"
+
+#include "QtxActionToolMgr.h"
+#include "QtxBackgroundTool.h"
+
+// VSR: Uncomment below line to allow texture background support in PV3D viewer
+#define PV3D_ENABLE_TEXTURED_BACKGROUND
+
+//---------------------------------------------------------
+#define USE_DEBUG
+#define MBCLASSNAME "SPV3D_ViewModel"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+/*!
+ Constructor
+*/
+SPV3D_ViewModel::SPV3D_ViewModel()
+{
+ DBG_FUN();
+ // myTrihedronSize = 105;
+ // myTrihedronRelative = true;
+ // myIsStaticTrihedronVisible = true;
+ // myIncrementSpeed = 10;
+ // myIncrementMode = 0;
+ // myProjMode = 0;
+ // myStereoType = 0;
+ // myAnaglyphFilter = 0;
+ // myStyle = 0;
+ // myZoomingStyle = 0;
+ mySelectionEnabled = true;
+ // myPreSelectionMode = Standard_Preselection;
+ // mySpaceBtn[0] = 1;
+ // mySpaceBtn[1] = 2;
+ // mySpaceBtn[2] = 9;
+ // myDefaultBackground = Qtx::BackgroundData( Qt::black );
+ // myQuadBufferSupport = false;
+}
+
+/*!
+ Destructor
+*/
+SPV3D_ViewModel::~SPV3D_ViewModel()
+{
+ DBG_FUN();
+}
+
+#if 0
+/*! Get data for supported background modes: gradient types, identifiers and supported image formats */
+QString SPV3D_ViewModel::backgroundData( QStringList& gradList, QIntList& idList, QIntList& txtList )
+{
+ gradList << tr( "GT_HORIZONTALGRADIENT" )
+ << tr( "GT_VERTICALGRADIENT" )
+ << tr( "GT_FIRSTDIAGONALGRADIENT" )
+ << tr( "GT_SECONDDIAGONALGRADIENT" )
+ << tr( "GT_FIRSTCORNERGRADIENT" )
+ << tr( "GT_SECONDCORNERGRADIENT" )
+ << tr( "GT_THIRDCORNERGRADIENT" )
+ << tr( "GT_FOURTHCORNERGRADIENT" );
+ idList << HorizontalGradient
+ << VerticalGradient
+ << FirstDiagonalGradient
+ << SecondDiagonalGradient
+ << FirstCornerGradient
+ << SecondCornerGradient
+ << ThirdCornerGradient
+ << FourthCornerGradient;
+#ifdef PV3D_ENABLE_TEXTURED_BACKGROUND
+ txtList << Qtx::CenterTexture << Qtx::TileTexture << Qtx::StretchTexture;
+#endif
+ return tr("BG_IMAGE_FILES");
+}
+
+/*! Get data for supported background modes: gradient types, identifiers and supported image formats */
+void SPV3D_ViewModel::stereoData( QStringList& typeList, QIntList& idList )
+{
+ typeList << tr("ST_CRYSTALEYES") << tr("ST_REDBLUE") <<
+ tr("ST_INTERLACED") << tr("ST_LEFT") <<
+ tr("ST_RIGHT") << tr("ST_DRESDEN") <<
+ tr("ST_ANAGLYPH") << tr("ST_CHECKERBOARD") <<
+ tr("ST_SPLITVIEWPORTHORIZONTAL");
+ idList << CrystalEyesType << RedBlueType <<
+ InterlacedType << LeftType <<
+ RightType << DresdenType <<
+ AnaglyphType << CheckerboardType <<
+ SplitViewPortHorizontalType;
+}
+
+//! Get background color of the viewer [obsolete]
+QColor SPV3D_ViewModel::backgroundColor() const
+{
+ return background().color();
+}
+
+//! Set background color to the viewer [obsolete]
+void SPV3D_ViewModel::setBackgroundColor( const QColor& c )
+{
+ DBG_FUN();
+ Qtx::BackgroundData bg = background();
+ bg.setColor( c );
+ setBackground( bg );
+}
+
+/*!
+ \return background data
+*/
+Qtx::BackgroundData SPV3D_ViewModel::background() const
+{
+ return myDefaultBackground;
+}
+
+/*!
+ Changes background
+ \param theBackground - new background data
+*/
+void SPV3D_ViewModel::setBackground( const Qtx::BackgroundData& theBackground )
+{
+ DBG_FUN();
+ myDefaultBackground = theBackground.isValid() ? theBackground : Qtx::BackgroundData( Qt::black );
+ QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
+ if(SUIT_ViewWindow* aViewWindow = aViews.at(i)){
+ if(SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViewWindow)){
+ aView->setBackground(myDefaultBackground);
+ }
+ }
+ }
+}
+#endif
+
+/*!Create new instance of view window on desktop \a theDesktop.
+ *\retval SUIT_ViewWindow* - created view window pointer.
+ */
+SUIT_ViewWindow* SPV3D_ViewModel::createView( SUIT_Desktop* theDesktop )
+{
+ DBG_FUN();
+ SPV3D_ViewWindow* aViewWindow = new SPV3D_ViewWindow(theDesktop, this);
+ //aViewWindow->Initialize(this);
+
+ // aViewWindow->setBackground( background() );
+ // aViewWindow->SetTrihedronSize( trihedronSize(), trihedronRelative() );
+ // aViewWindow->SetStaticTrihedronVisible( isStaticTrihedronVisible() );
+ // aViewWindow->SetProjectionMode( projectionMode() );
+ // aViewWindow->SetStereoType( stereoType() );
+ // aViewWindow->SetAnaglyphFilter( anaglyphFilter() );
+ // aViewWindow->SetQuadBufferSupport( isQuadBufferSupport() );
+ // aViewWindow->SetInteractionStyle( interactionStyle() );
+ // aViewWindow->SetZoomingStyle( zoomingStyle() );
+ // aViewWindow->SetPreSelectionMode( preSelectionMode() );
+ aViewWindow->SetSelectionEnabled( isSelectionEnabled() );
+ // aViewWindow->SetIncrementalSpeed( incrementalSpeed(), incrementalSpeedMode() );
+ // aViewWindow->SetSpacemouseButtons( spacemouseBtn(1), spacemouseBtn(2), spacemouseBtn(3) );
+
+ // connect(aViewWindow, SIGNAL( actorAdded(PV3DViewer_Actor*) ),
+ // this, SLOT(onActorAdded(PV3DViewer_Actor*)));
+ // connect(aViewWindow, SIGNAL( actorRemoved(PV3DViewer_Actor*) ),
+ // this, SLOT(onActorRemoved(PV3DViewer_Actor*)));
+
+ return aViewWindow;
+}
+
+#if 0
+/*!
+ \return trihedron size
+*/
+double SPV3D_ViewModel::trihedronSize() const
+{
+ return myTrihedronSize;
+}
+
+/*!
+ \return true if thihedron changes size in accordance with bounding box
+*/
+bool SPV3D_ViewModel::trihedronRelative() const
+{
+ return myTrihedronRelative;
+}
+
+/*!
+ Sets trihedron size and relativeness( whether thihedron changes size in accordance with bounding box)
+ \param theSize - new size
+ \param theRelative - new relativeness
+*/
+void SPV3D_ViewModel::setTrihedronSize( const double theSize, const bool theRelative )
+{
+ myTrihedronSize = theSize;
+ myTrihedronRelative = theRelative;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetTrihedronSize( theSize, theRelative );
+ }
+ }
+}
+
+/*!
+ \return visibility status of the static trihedron
+*/
+bool SPV3D_ViewModel::isStaticTrihedronVisible() const
+{
+ return myIsStaticTrihedronVisible;
+}
+
+/*!
+ Sets visibility status of the static trihedron
+ \param theIsVisible - new visibility status
+*/
+void SPV3D_ViewModel::setStaticTrihedronVisible( const bool theIsVisible )
+{
+ myIsStaticTrihedronVisible = theIsVisible;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetStaticTrihedronVisible( theIsVisible );
+ }
+ }
+}
+
+/*!
+ \return projection mode
+*/
+int SPV3D_ViewModel::projectionMode() const
+{
+ return myProjMode;
+}
+
+
+/*!
+ Sets projection mode: 0 - orthogonal, 1 - perspective projection
+ \param theMode - new projection mode
+*/
+void SPV3D_ViewModel::setProjectionMode( const int theMode )
+{
+ DBG_FUN();
+ if ( myProjMode != theMode ) {
+ if ( theMode != SPV3D_ViewWindow::Stereo )
+ myProjMode = theMode;
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetProjectionMode( theMode );
+ }
+ }
+ }
+}
+
+/*!
+ \return stereo type
+*/
+int SPV3D_ViewModel::stereoType() const
+{
+ return myStereoType;
+}
+
+/*!
+ Sets stereo type
+ \param theType - new stereo type
+*/
+void SPV3D_ViewModel::setStereoType( const int theType )
+{
+ if ( myStereoType != theType ) {
+ myStereoType = theType;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetStereoType( theType );
+ }
+ }
+ }
+}
+
+/*!
+ \return anaglyph filter
+*/
+int SPV3D_ViewModel::anaglyphFilter() const
+{
+ return myAnaglyphFilter;
+}
+
+/*!
+ Sets anaglyph filter
+ \param theFilter - new anaglyph filter
+*/
+void SPV3D_ViewModel::setAnaglyphFilter( const int theFilter )
+{
+ if ( myAnaglyphFilter != theFilter ) {
+ myAnaglyphFilter = theFilter;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetAnaglyphFilter( theFilter );
+ }
+ }
+ }
+}
+
+/*!
+ \return support quad-buffered stereo
+*/
+bool SPV3D_ViewModel::isQuadBufferSupport() const
+{
+ return myQuadBufferSupport;
+}
+
+/*!
+ Set support quad-buffered stereo
+ \param theEnable - enable/disable support quad-buffered stereo
+*/
+void SPV3D_ViewModel::setQuadBufferSupport( const bool theEnable )
+{
+ DBG_FUN();
+ if ( myQuadBufferSupport != theEnable ) {
+ myQuadBufferSupport = theEnable;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetQuadBufferSupport( theEnable );
+ }
+ }
+ }
+}
+/*!
+ \return interaction style
+*/
+int SPV3D_ViewModel::interactionStyle() const
+{
+ return myStyle;
+}
+
+/*!
+ Sets interaction style: 0 - standard, 1 - keyboard free interaction
+ \param theStyle - new interaction style
+*/
+void SPV3D_ViewModel::setInteractionStyle( const int theStyle )
+{
+ myStyle = theStyle;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetInteractionStyle( theStyle );
+ }
+ }
+}
+
+/*!
+ \return zooming style
+*/
+int SPV3D_ViewModel::zoomingStyle() const
+{
+ return myZoomingStyle;
+}
+
+/*!
+ Sets zooming style: 0 - standard, 1 - advanced (at cursor)
+ \param theStyle - new zooming style
+*/
+void SPV3D_ViewModel::setZoomingStyle( const int theStyle )
+{
+ myZoomingStyle = theStyle;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetZoomingStyle( theStyle );
+ }
+ }
+}
+
+/*!
+ \return current preselection mode
+*/
+Preselection_Mode SPV3D_ViewModel::preSelectionMode() const
+{
+ return myPreSelectionMode;
+}
+
+/*!
+ Sets preselection mode
+ \param theMode - new preselection mode
+*/
+void SPV3D_ViewModel::setPreSelectionMode( Preselection_Mode theMode )
+{
+ myPreSelectionMode = theMode;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetPreSelectionMode( theMode );
+ }
+ }
+}
+
+/*!
+ \return incremental speed value
+*/
+int SPV3D_ViewModel::incrementalSpeed() const
+{
+ return myIncrementSpeed;
+}
+
+/*!
+ \return modification mode of the incremental speed
+*/
+int SPV3D_ViewModel::incrementalSpeedMode() const
+{
+ return myIncrementMode;
+}
+
+/*!
+ Set the incremental speed value and modification mode
+ \param theValue - new value
+ \param theMode - new mode: 0 - arithmetic, 1 - geometrical progression
+*/
+void SPV3D_ViewModel::setIncrementalSpeed( const int theValue, const int theMode )
+{
+ myIncrementSpeed = theValue;
+ myIncrementMode = theMode;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetIncrementalSpeed( theValue, theMode );
+ }
+ }
+}
+
+/*!
+ \return spacemouse button assigned to the specified function
+ \param theIndex - function by number (from 1 to 3)
+*/
+int SPV3D_ViewModel::spacemouseBtn( const int theIndex ) const
+{
+ if ( theIndex < 1 || theIndex > 3 )
+ return -1;
+ return mySpaceBtn[theIndex-1];
+}
+
+/*!
+ Set the spacemouse buttons
+ \param theBtn1, theBtn2, theBtn3 - new buttons
+*/
+void SPV3D_ViewModel::setSpacemouseButtons( const int theBtn1, const int theBtn2, const int theBtn3 )
+{
+ mySpaceBtn[0] = theBtn1;
+ mySpaceBtn[1] = theBtn2;
+ mySpaceBtn[2] = theBtn3;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetSpacemouseButtons( theBtn1, theBtn2, theBtn3 );
+ }
+ }
+}
+#endif
+
+/*!
+ Sets new view manager
+ \param theViewManager - new view manager
+*/
+void SPV3D_ViewModel::setViewManager(SUIT_ViewManager* theViewManager)
+{
+ DBG_FUN();
+ SUIT_ViewModel::setViewManager(theViewManager);
+
+ if ( !theViewManager )
+ return;
+
+ connect(theViewManager, SIGNAL(mousePress(SUIT_ViewWindow*, QMouseEvent*)),
+ this, SLOT(onMousePress(SUIT_ViewWindow*, QMouseEvent*)));
+
+ connect(theViewManager, SIGNAL(mouseMove(SUIT_ViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMove(SUIT_ViewWindow*, QMouseEvent*)));
+
+ connect(theViewManager, SIGNAL(mouseRelease(SUIT_ViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseRelease(SUIT_ViewWindow*, QMouseEvent*)));
+
+ connect(theViewManager, SIGNAL(viewCreated(SUIT_ViewWindow*)),
+ this, SLOT(onViewCreated(SUIT_ViewWindow*)));
+}
+
+/*!
+ Builds popup for vtk viewer
+*/
+void SPV3D_ViewModel::contextMenuPopup( QMenu* thePopup )
+{
+ DBG_FUN();
+ // thePopup->addAction( PV3DViewer_Viewer::tr( "MEN_DUMP_VIEW" ), this, SLOT( onDumpView() ) );
+ // thePopup->addAction( PV3DViewer_Viewer::tr( "MEN_CHANGE_BACKGROUND" ), this, SLOT( onChangeBackground() ) );
+
+ // thePopup->addSeparator();
+
+ // if(SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(myViewManager->getActiveView())){
+ // //Support of several toolbars in the popup menu
+ // QList<QToolBar*> lst = aView->findChildren<QToolBar*>();
+ // QList<QToolBar*>::const_iterator it = lst.begin(), last = lst.end();
+ // for( ; it!=last; it++ )
+ // thePopup->addAction( (*it)->toggleViewAction() );
+ // aView->RefreshDumpImage();
+ // }
+}
+
+/*!
+ SLOT: called on mouse button press, empty implementation
+*/
+void SPV3D_ViewModel::onMousePress(SUIT_ViewWindow* /*vw*/, QMouseEvent* /*event*/)
+{}
+
+/*!
+ SLOT: called on mouse move, empty implementation
+*/
+void SPV3D_ViewModel::onMouseMove(SUIT_ViewWindow* /*vw*/, QMouseEvent* /*event*/)
+{}
+
+/*!
+ SLOT: called on mouse button release, empty implementation
+*/
+void SPV3D_ViewModel::onMouseRelease(SUIT_ViewWindow* /*vw*/, QMouseEvent* /*event*/)
+{}
+
+/*!
+ Enables/disables selection
+ \param isEnabled - new state
+*/
+void SPV3D_ViewModel::enableSelection(bool isEnabled)
+{
+ DBG_FUN();
+ ARG(isEnabled);
+ mySelectionEnabled = isEnabled;
+ //!! To be done for view windows
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( int i = 0; i < aViews.count(); i++ )
+ {
+ if ( SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(aViews.at( i )) )
+ aView->SetSelectionEnabled( isEnabled );
+ }
+ }
+
+ if(!isEnabled) {
+ //clear current selection in the viewer
+ bool blocked = blockSignals( true );
+ if ( SUIT_ViewManager* aViewMgr = getViewManager() ) {
+ if( SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>( aViewMgr->getActiveView() ) ){
+ //NYI
+ // if( SPV3D_Selector* aSelector = aViewWindow->GetSelector() ) {
+ // if(SPV3D_View* aView = aViewWindow->getView()){
+ // aSelector->ClearIObjects();
+ // aView->onSelectionChanged();
+ // }
+ // }
+ }
+ }
+ blockSignals( blocked );
+ }
+
+}
+
+#if 0
+/*!
+ Enables/disables selection of many object
+ \param isEnabled - new state
+*/
+void SPV3D_ViewModel::enableMultiselection(bool isEnable)
+{
+ myMultiSelectionEnabled = isEnable;
+ //!! To be done for view windows
+}
+
+/*!
+ SLOT: called on dump view operation is activated, stores scene to raster file
+*/
+void SPV3D_ViewModel::onDumpView()
+{
+ if(SUIT_ViewWindow* aView = myViewManager->getActiveView())
+ aView->onDumpView();
+}
+
+/*!
+ SLOT: called if background color is to be changed changed, passes new color to view port
+*/
+void SPV3D_ViewModel::onChangeBackground()
+{
+ SPV3D_ViewWindow* aView = dynamic_cast<SPV3D_ViewWindow*>(myViewManager->getActiveView());
+ if ( !aView )
+ return;
+
+ // get supported gradient types
+ QStringList gradList;
+ QIntList idList, txtList;
+ QString formats = backgroundData( gradList, idList, txtList );
+
+ // invoke dialog box
+ Qtx::BackgroundData bgData = QtxBackgroundDialog::getBackground( aView->background(), // initial background
+ aView, // parent for dialog box
+ txtList, // allowed texture modes
+ true, // enable solid color mode
+ true, // enable gradient mode
+ false, // disable custom gradient mode
+ !txtList.isEmpty(), // enable texture mode
+ gradList, // gradient names
+ idList, // gradient identifiers
+ formats ); // image formats
+
+ // set chosen background data to the viewer
+ if ( bgData.isValid() )
+ aView->setBackground( bgData );
+}
+#endif
+
+/*!
+ Display presentation
+ \param prs - presentation
+*/
+void SPV3D_ViewModel::Display( const SALOME_PV3DPrs* prs )
+{
+ DBG_FUN();
+ // try do downcast object
+ if(const SPV3D_Prs* aPrs = dynamic_cast<const SPV3D_Prs*>( prs )){
+ if(aPrs->IsNull())
+ return;
+ if(vtkActorCollection* anActorCollection = aPrs->GetObjects()){
+ anActorCollection->InitTraversal();
+ while(vtkActor* anActor = anActorCollection->GetNextActor()){
+ // if(SALOME_Actor* anAct = SALOME_Actor::SafeDownCast(anActor)){
+ // if(!anAct->ShouldBeDisplayed())
+ // continue;
+ // // just display the object
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
+ // if(SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>(aViews.at(i))){
+ // // if(SPV3D_View* aView = aViewWindow->getView()){
+ // // aView->Display(anAct,false);
+ // // if(anAct->IsSetCamera()){
+ // // vtkRenderer* aRenderer = aView->getRenderer();
+ // // anAct->SetCamera( aRenderer->GetActiveCamera() );
+ // // }
+ // // }
+ // }
+ // }
+ // }
+ }
+ }
+ }
+}
+
+/*!
+ Erase presentation
+ \param prs - presentation
+ \param forced - removes object from view
+*/
+void SPV3D_ViewModel::Erase( const SALOME_PV3DPrs* prs, const bool forced )
+{
+ DBG_FUN();
+ // try do downcast object
+ // if(const SPV3D_Prs* aPrs = dynamic_cast<const SPV3D_Prs*>( prs )){
+ // if(aPrs->IsNull())
+ // return;
+ // if(vtkActorCollection* anActorCollection = aPrs->GetObjects()){
+ // anActorCollection->InitTraversal();
+ // while(vtkActor* anActor = anActorCollection->GetNextActor())
+ // if(SALOME_Actor* anAct = SALOME_Actor::SafeDownCast(anActor)){
+ // // Set visibility flag
+ // // Temporarily commented to avoid awful dependecy on SALOMEDS
+ // // TODO: better mechanism of storing display/erase status in a study
+ // // should be provided...
+ // //Handle(SALOME_InteractiveObject) anObj = anAct->getIO();
+ // //if(!anObj.IsNull() && anObj->hasEntry()){
+ // // ToolsGUI::SetVisibility(anObj->getEntry(),false,this);
+ // //}
+ // // just display the object
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
+ // if(SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>(aViews.at(i)))
+ // if(SPV3D_View* aView = aViewWindow->getView())
+ // {
+ // if ( forced )
+ // aView->Remove(anAct,false);
+ // else
+ // aView->Erase(anAct,forced);
+ // }
+ // }
+ // }
+ // }
+ // }
+}
+
+/*!
+ Erase all presentations
+ \param forced - removes all objects from view
+*/
+void SPV3D_ViewModel::EraseAll( SALOME_Displayer* d, const bool forced )
+{
+ DBG_FUN();
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++){
+ // if(SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>(aViews.at(i)))
+ // if(SPV3D_View* aView = aViewWindow->getView()){
+ // vtkRenderer* aRenderer = aView->getRenderer();
+ // PV3D::ActorCollectionCopy aCopy(aRenderer->GetActors());
+ // vtkActorCollection* anActorCollection = aCopy.GetActors();
+ // anActorCollection->InitTraversal();
+ // while(vtkActor* anActor = anActorCollection->GetNextActor()){
+ // if(SALOME_Actor* anAct = SALOME_Actor::SafeDownCast(anActor)){
+ // // Set visibility flag
+ // // Temporarily commented to avoid awful dependecy on SALOMEDS
+ // // TODO: better mechanism of storing display/erse status in a study
+ // // should be provided...
+ // //Handle(SALOME_InteractiveObject) anObj = anAct->getIO();
+ // //if(!anObj.IsNull() && anObj->hasEntry())
+ // // ToolsGUI::SetVisibility(anObj->getEntry(),false,this);
+ // if(forced){
+ // if(SPV3D_Renderer* aRnd = aView->GetRenderer())
+ // aRnd->RemoveActor(anAct);
+ // }else{
+ // // just erase actor
+ // anAct->SetVisibility( false );
+ // // erase dependent actors
+ // vtkActorCollection* aCollection = vtkActorCollection::New();
+ // anAct->GetChildActors( aCollection );
+ // aCollection->InitTraversal();
+ // while(vtkActor* aSubAct = aCollection->GetNextActor())
+ // aSubAct->SetVisibility( false );
+ // aCollection->Delete();
+ // }
+ // }
+ // }
+ // }
+ // }
+
+ SALOME_View::EraseAll( d, forced );
+
+ Repaint();
+}
+
+/*!
+ Create presentation corresponding to the entry
+ \param entry - entry
+*/
+SALOME_Prs* SPV3D_ViewModel::CreatePrs( const char* entry )
+{
+ DBG_FUN();
+ ARG(entry);
+ SPV3D_Prs* prs = new SPV3D_Prs( entry );
+ // if ( entry ) {
+ // if(SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>(getViewManager()->getActiveView()))
+ // if(SPV3D_View* aView = aViewWindow->getView()){
+ // vtkRenderer* aRenderer = aView->getRenderer();
+ // PV3D::ActorCollectionCopy aCopy(aRenderer->GetActors());
+ // vtkActorCollection* theActors = aCopy.GetActors();
+ // theActors->InitTraversal();
+ // vtkActor* ac;
+ // while( ( ac = theActors->GetNextActor() ) ) {
+ // SALOME_Actor* anActor = SALOME_Actor::SafeDownCast( ac );
+ // if ( anActor && anActor->hasIO() && !strcmp( anActor->getIO()->getEntry(), entry ) ) {
+ // prs->AddObject( ac );
+ // }
+ // }
+ // }
+ // }
+ return prs;
+}
+
+/*!
+ \return true if object is displayed in viewer
+ \param obj - object to be checked
+*/
+bool SPV3D_ViewModel::isVisible( const Handle(SALOME_InteractiveObject)& io )
+{
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++)
+ // if(SUIT_ViewWindow* aViewWindow = aViews.at(i))
+ // if(SPV3D_ViewWindow* aViewWnd = dynamic_cast<SPV3D_ViewWindow*>(aViewWindow))
+ // if(SPV3D_View* aView = aViewWnd->getView())
+ // if(!aView->isVisible( io ))
+ // return false;
+ return false;
+}
+
+/*!
+ \Collect objects visible in viewer
+ \param theList - visible objects collection
+*/
+void SPV3D_ViewModel::GetVisible( SALOME_ListIO& theList )
+{
+ // here we collect object if it is disaplaed even one view
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++)
+ // if(SUIT_ViewWindow* aViewWindow = aViews.at(i))
+ // if(SPV3D_ViewWindow* aViewWnd = dynamic_cast<SPV3D_ViewWindow*>(aViewWindow))
+ // if(SPV3D_View* aView = aViewWnd->getView())
+ // aView->GetVisible( theList );
+}
+
+/*!
+ Updates current viewer
+*/
+void SPV3D_ViewModel::Repaint()
+{
+ DBG_FUN();
+// if (theUpdateTrihedron) onAdjustTrihedron();
+ // QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ // for(int i = 0, iEnd = aViews.size(); i < iEnd; i++)
+ // if(SPV3D_ViewWindow* aViewWindow = dynamic_cast<SPV3D_ViewWindow*>(aViews.at(i)))
+ // if(SPV3D_View* aView = aViewWindow->getView())
+ // aView->Repaint();
+}
+
+
+#if 0
+void SPV3D_ViewModel::onActorAdded(PV3DViewer_Actor* theActor)
+{
+ DBG_FUN();
+ MSGEL("-----> emit actorAdded <-----");
+ emit actorAdded((SPV3D_ViewWindow*)sender(), theActor);
+}
+
+void SPV3D_ViewModel::onActorRemoved(PV3DViewer_Actor* theActor)
+{
+ DBG_FUN();
+ MSGEL("-----> emit actorRemoved <-----");
+ emit actorRemoved((SPV3D_ViewWindow*)sender(), theActor);
+}
+#endif
+
+void SPV3D_ViewModel::onViewCreated( SUIT_ViewWindow* view) {
+ DBG_FUN();
+#ifdef VGL_WORKAROUND
+ if ( SPV3D_ViewWindow* svw = dynamic_cast<SPV3D_ViewWindow*>( view ) )
+ QTimer::singleShot(500, [svw] () { svw->Repaint(); } );
+#endif
+}
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef SPV3D_VIEWMODEL_H
+#define SPV3D_VIEWMODEL_H
+
+#include "SPV3D.h"
+//#include "SPV3D_ViewModelBase.h"
+//#include "SPV3D_Selection.h"
+//#include "SUIT_ViewModel.h"
+#include "PV3DViewer_ViewModel.h"
+
+#include "Qtx.h"
+
+#include <SALOME_Prs.h>
+#include <SALOME_InteractiveObject.hxx>
+#include <SALOME_ListIO.hxx>
+
+#include <QColor>
+#include <QMap>
+
+class QMouseEvent;
+
+class SPV3D_ViewWindow;
+class PV3DViewer_Actor;
+
+//! Extends two interfaces #SPV3D_ViewModelBase and #SALOME_View
+class SPV3D_EXPORT SPV3D_ViewModel : public PV3DViewer_ViewModel, public SALOME_View
+{
+ Q_OBJECT
+
+public:
+ /*! supported gradient types */
+ // enum {
+ // HorizontalGradient,
+ // VerticalGradient,
+ // FirstDiagonalGradient,
+ // SecondDiagonalGradient,
+ // FirstCornerGradient,
+ // SecondCornerGradient,
+ // ThirdCornerGradient,
+ // FourthCornerGradient,
+ // LastGradient = FourthCornerGradient,
+ // };
+
+ // enum {
+ // CrystalEyesType, RedBlueType,
+ // InterlacedType, LeftType,
+ // RightType, DresdenType,
+ // AnaglyphType, CheckerboardType,
+ // SplitViewPortHorizontalType
+ // };
+ // typedef SPV3D_ViewWindow TViewWindow;
+
+ //! Define string representation of the viewer type
+ static QString Type() { return "ParaView3D"; }
+ // static QString backgroundData( QStringList&, QIntList&, QIntList& );
+ // static void stereoData( QStringList&, QIntList&);
+
+ SPV3D_ViewModel();
+ virtual ~SPV3D_ViewModel();
+
+ //! See #SUIT_ViewModel::createView
+ virtual SUIT_ViewWindow* createView(SUIT_Desktop*);
+
+ //! See #SUIT_ViewModel::createView
+ virtual void setViewManager(SUIT_ViewManager* theViewManager);
+
+ //! See #SUIT_ViewModel::contextMenuPopup
+ virtual void contextMenuPopup( QMenu* );
+
+ //! See #SUIT_ViewModel::getType
+ virtual QString getType() const { return Type(); }
+
+ // //! Get background color of the viewer [obsolete]
+ // QColor backgroundColor() const;
+
+ // //! Set background color to the viewer [obsolete]
+ // void setBackgroundColor( const QColor& );
+
+ // //! Get background color of the viewer
+ // Qtx::BackgroundData background() const;
+
+ // //! Set background color to the viewer
+ // void setBackground( const Qtx::BackgroundData& );
+
+ // //! Get size of trihedron of the viewer (see #SPV3D_Renderer::SetTrihedronSize)
+ // double trihedronSize() const;
+
+ // //! Shows if the size of trihedron relative (see #SPV3D_Renderer::SetTrihedronSize)
+ // bool trihedronRelative() const;
+
+ // //! Set size of trihedron of the viewer (see #SPV3D_Renderer::SetTrihedronSize)
+ // void setTrihedronSize( const double, const bool = true );
+
+ // //! Get visibility status of the static trihedron
+ // bool isStaticTrihedronVisible() const;
+
+ // //! Set visibility status of the static trihedron
+ // void setStaticTrihedronVisible( const bool );
+
+ // //! Gets projection mode
+ // int projectionMode() const;
+
+ // //! Sets projection mode
+ // void setProjectionMode( const int );
+
+ // //! Gets stereo type
+ // int stereoType() const;
+
+ // //! Sets stereo type
+ // void setStereoType( const int );
+
+ // //! Gets anaglyph filter
+ // int anaglyphFilter() const;
+
+ // //! Sets anaglyph filter
+ // void setAnaglyphFilter( const int );
+
+ // //! Get support quad-buffered stereo
+ // bool isQuadBufferSupport() const;
+
+ // //! Set support quad-buffered stereo
+ // void setQuadBufferSupport( const bool );
+
+ // //! Gets interaction style
+ // int interactionStyle() const;
+
+ // //! Sets interaction style
+ // void setInteractionStyle( const int );
+
+ // //! Gets zooming style
+ // int zoomingStyle() const;
+
+ // //! Sets zooming style
+ // void setZoomingStyle( const int );
+
+ // //! Gets current preselection mode (standard, dynamic or disabled)
+ // Preselection_Mode preSelectionMode() const;
+
+ // //! Sets new preselection mode
+ // void setPreSelectionMode( Preselection_Mode );
+
+ // //! Get incremental speed (see #SPV3D_InteractorStyle::ControllerIncrement)
+ // int incrementalSpeed() const;
+
+ // //! Returns modification mode of incremental speed (see #SPV3D_InteractorStyle::ControllerIncrement)
+ // int incrementalSpeedMode() const;
+
+ // //! Set the incremental speed for view operation (see #SPV3D_InteractorStyle::ControllerIncrement)
+ // void setIncrementalSpeed( const int, const int = 0 );
+
+ // //! Gets spacemouse button for specified function
+ // int spacemouseBtn( const int ) const;
+
+ // //! Sets spacemouse buttons
+ // void setSpacemouseButtons( const int, const int, const int );
+
+public:
+ void enableSelection(bool isEnabled);
+ bool isSelectionEnabled() const { return mySelectionEnabled; }
+
+ // void enableMultiselection(bool isEnable);
+ // bool isMultiSelectionEnabled() const { return myMultiSelectionEnabled; }
+
+ // int getSelectionCount() const;
+
+ /* Reimplemented from SALOME_View */
+
+ //! See #SALOME_View::Display( const SALOME_Prs* )
+ void Display( const SALOME_PV3DPrs* );
+
+ //! See #SALOME_View::Erase( const SALOME_PV3DPrs*, const bool = false )
+ void Erase( const SALOME_PV3DPrs*, const bool = false );
+
+ //! See #SALOME_View::EraseAll( SALOME_Displayer*, const bool = false )
+ void EraseAll( SALOME_Displayer*, const bool = false );
+
+ //! See #SALOME_View::getVisible( SALOME_ListIO& )
+ virtual void GetVisible( SALOME_ListIO& );
+
+ //! See #SALOME_View::CreatePrs( const char* entry = 0 )
+ SALOME_Prs* CreatePrs( const char* entry = 0 );
+
+ //! See #SALOME_View::isVisible( const Handle(SALOME_InteractiveObject)& )
+ virtual bool isVisible( const Handle(SALOME_InteractiveObject)& );
+
+ //! See #SALOME_View::Repaint()
+ virtual void Repaint();
+
+// signals:
+// void actorAdded(SPV3D_ViewWindow*, PV3DViewer_Actor*);
+// void actorRemoved(SPV3D_ViewWindow*, PV3DViewer_Actor*);
+
+protected slots:
+ void onMousePress(SUIT_ViewWindow*, QMouseEvent*);
+ void onMouseMove(SUIT_ViewWindow*, QMouseEvent*);
+ void onMouseRelease(SUIT_ViewWindow*, QMouseEvent*);
+
+ // void onDumpView();
+ // void onChangeBackground();
+
+ // void onActorAdded(PV3DViewer_Actor*);
+ // void onActorRemoved(PV3DViewer_Actor*);
+
+ void onViewCreated( SUIT_ViewWindow* );
+
+private:
+ // void updateToolBars();
+
+ // Qtx::BackgroundData myDefaultBackground;
+ // double myTrihedronSize;
+ // bool myTrihedronRelative;
+ // bool myIsStaticTrihedronVisible;
+ bool mySelectionEnabled;
+ // bool myMultiSelectionEnabled;
+ // int myIncrementSpeed;
+ // int myIncrementMode;
+ // int myProjMode;
+ // int myStereoType;
+ // int myAnaglyphFilter;
+ // bool myQuadBufferSupport;
+ // int myStyle;
+ // int myZoomingStyle;
+ // Preselection_Mode myPreSelectionMode;
+ // int mySpaceBtn[3];
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "SPV3D_ViewWindow.h"
+
+// #include "SPV3D_NonIsometricDlg.h"
+// #include "SPV3D_UpdateRateDlg.h"
+// #include "SPV3D_CubeAxesDlg.h"
+// #include "SPV3D_PsOptionsDlg.h"
+// #include "SPV3D_SetRotationPointDlg.h"
+// #include "SPV3D_ViewParameterDlg.h"
+#include "SPV3D_ViewModel.h"
+// #include "PV3DViewer_Texture.h"
+// #include "PV3DViewer_OpenGLRenderer.h"
+
+//#include "SALOME_Actor.h"
+
+#include <QMenu>
+#include <QToolBar>
+#include <QTimer>
+#include <QEvent>
+#include <QFileInfo>
+#include <QSignalMapper>
+#include <QXmlStreamWriter>
+#include <QXmlStreamReader>
+#include <QXmlStreamAttributes>
+
+// #include <vtkTextProperty.h>
+// #include <vtkActorCollection.h>
+// #include <vtkRenderWindow.h>
+// #include <vtkRenderer.h>
+// #include <vtkCamera.h>
+// #include <vtkPointPicker.h>
+// #include <vtkCellPicker.h>
+// #include <vtkAxisActor2D.h>
+// #include <vtkGL2PSExporter.h>
+// #include <vtkInteractorStyle.h>
+// #include <vtkProperty.h>
+// #include <vtkCallbackCommand.h>
+// #include <vtkJPEGReader.h>
+// #include <vtkBMPReader.h>
+// #include <vtkTIFFReader.h>
+// #include <vtkPNGReader.h>
+// #include <vtkMetaImageReader.h>
+// #include <vtkImageMapToColors.h>
+// #include <vtkTexture.h>
+
+#include "QtxAction.h"
+
+#include "SUIT_Session.h"
+#include "SUIT_MessageBox.h"
+#include "SUIT_Accel.h"
+#include "SUIT_Tools.h"
+#include "SUIT_ResourceMgr.h"
+#include "SUIT_Accel.h"
+#include "SUIT_OverrideCursor.h"
+#include "SUIT_ViewManager.h"
+#include "QtxActionToolMgr.h"
+#include "QtxMultiAction.h"
+#include "QtxActionGroup.h"
+
+// #include "PV3DViewer_Utilities.h"
+// #include "PV3DViewer_Trihedron.h"
+// #include "PV3DViewer_Actor.h"
+
+//#include "SPV3D_View.h"
+// #include "SPV3D_Selector.h"
+
+// #include "SPV3D_Event.h"
+// #include "SPV3D_Renderer.h"
+// #include "SPV3D_InteractorStyle.h"
+// #include "SPV3D_RenderWindowInteractor.h"
+// #include "SPV3D_GenericRenderWindowInteractor.h"
+// #include "SPV3D_CubeAxesActor2D.h"
+// #include "SPV3D_ComboAction.h"
+// #include "SPV3D_KeyFreeInteractorStyle.h"
+// #include "SPV3D_Selector.h"
+// #include "SPV3D_Recorder.h"
+// #include "SPV3D_RecorderDlg.h"
+
+// #include "salomevtkPVAxesWidget.h"
+// #include "salomevtkPVAxesActor.h"
+
+#include "SALOME_ListIO.hxx"
+
+//#include "PV3DViewer_Algorithm.h"
+// #include "SPV3D_Functor.h"
+
+//#include <OpenGLUtils_FrameBuffer.h>
+
+// #ifdef __APPLE__
+// #include <OpenGL/gl.h>
+// #else
+// #include <GL/gl.h>
+// #endif
+
+//---------------------------------------------------------
+#define USE_DEBUG
+#define MBCLASSNAME "SPV3D_ViewWindow"
+#include "MBDebug.h"
+//---------------------------------------------------------
+
+// Use workaround for rendering transparent object over MESA
+#define USE_WORKAROUND_FOR_MESA
+
+namespace SPV3D
+{
+ // int convertAction( const int accelAction )
+ // {
+ // switch ( accelAction ) {
+ // case SUIT_Accel::PanLeft : return SPV3D::PanLeftEvent;
+ // case SUIT_Accel::PanRight : return SPV3D::PanRightEvent;
+ // case SUIT_Accel::PanUp : return SPV3D::PanUpEvent;
+ // case SUIT_Accel::PanDown : return SPV3D::PanDownEvent;
+ // case SUIT_Accel::ZoomIn : return SPV3D::ZoomInEvent;
+ // case SUIT_Accel::ZoomOut : return SPV3D::ZoomOutEvent;
+ // case SUIT_Accel::RotateLeft : return SPV3D::RotateLeftEvent;
+ // case SUIT_Accel::RotateRight : return SPV3D::RotateRightEvent;
+ // case SUIT_Accel::RotateUp : return SPV3D::RotateUpEvent;
+ // case SUIT_Accel::RotateDown : return SPV3D::RotateDownEvent;
+ // }
+ // return accelAction;
+ // }
+}
+
+/*!
+ Constructor
+*/
+SPV3D_ViewWindow::SPV3D_ViewWindow(SUIT_Desktop* theDesktop, SPV3D_ViewModel* theModel):
+ PV3DViewer_ViewWindow(theDesktop, theModel), //SUIT_ViewWindow(theDesktop),
+ myModel(theModel),
+ myView(NULL)//,
+ // myKeyFreeInteractorStyle(SPV3D_KeyFreeInteractorStyle::New()),
+ // myEventCallbackCommand(vtkCallbackCommand::New()),
+ // myDumpImage(QImage())
+{
+ DBG_FUN();
+ //setWindowFlags( windowFlags() & ~Qt::Window );
+ // // specific of vtkSmartPointer
+ // myKeyFreeInteractorStyle->Delete();
+}
+
+#if 0
+/*!
+ To initialize #SPV3D_ViewWindow instance
+*/
+void SPV3D_ViewWindow::Initialize(SPV3D_ViewModel/*Base*/* theModel)
+{
+ DBG_FUN();
+ myModel = theModel;
+ // myInteractor = new SPV3D_RenderWindowInteractor(this,"SPV3D_RenderWindowInteractor");
+
+ // SPV3D_Selector* aSelector = SPV3D_Selector::New();
+ // int aPreselectionMode = SUIT_Session::session()->resourceMgr()->
+ // integerValue( "PV3DViewer", "preselection", Standard_Preselection );
+ // aSelector->SetDynamicPreSelection( aPreselectionMode == Dynamic_Preselection );
+ // aSelector->SetPreSelectionEnabled( aPreselectionMode != Preselection_Disabled );
+ // bool isSelectionEnabled = SUIT_Session::session()->resourceMgr()->booleanValue( "PV3DViewer", "enable_selection", true );
+ // aSelector->SetSelectionEnabled( isSelectionEnabled );
+
+ // SPV3D_GenericRenderWindowInteractor* aDevice = SPV3D_GenericRenderWindowInteractor::New();
+ // aDevice->SetRenderWidget(myInteractor);
+ // aDevice->SetSelector(aSelector);
+
+ // SPV3D_Renderer* aRenderer = SPV3D_Renderer::New();
+ // aRenderer->Initialize(aDevice,aSelector);
+
+ // myInteractor->Initialize(aDevice,aRenderer,aSelector);
+
+ // aDevice->Delete();
+ // aRenderer->Delete();
+ // aSelector->Delete();
+
+ // myToolBar = toolMgr()->createToolBar( tr("LBL_TOOLBAR_LABEL"), // title (language-dependant)
+ // QString( "PV3DViewerViewOperations" ), // name (language-independant)
+ // false ); // disable floatable toolbar
+
+ // myRecordingToolBar = toolMgr()->createToolBar( tr("LBL_TOOLBAR_RECORD_LABEL"), // title (language-dependant)
+ // QString( "PV3DRecordingOperations" ), // name (language-independant)
+ // false ); // disable floatable toolbar
+
+ // createActions( SUIT_Session::session()->resourceMgr() );
+ // createToolBar();
+
+ // SetEventDispatcher(myInteractor->GetDevice());
+ // myInteractor->setBackgroundRole( QPalette::NoRole );//NoBackground
+ // myInteractor->setFocusPolicy(Qt::StrongFocus);
+ // myInteractor->setFocus();
+ // bool isSupportQuadBuffer = SUIT_Session::session()->resourceMgr()->
+ // booleanValue( "PV3DViewer", "enable_quad_buffer_support", false );
+ // myInteractor->getRenderWindow()->SetStereoCapableWindow((int)isSupportQuadBuffer);
+ // setFocusProxy(myInteractor);
+
+ // myUpdateRateDlg = new SPV3D_UpdateRateDlg( getAction( UpdateRate ), this, "SPV3D_UpdateRateDlg" );
+ // myNonIsometricDlg = new SPV3D_NonIsometricDlg( getAction( NonIsometric ), this, "SPV3D_NonIsometricDlg" );
+ // myCubeAxesDlg = new SPV3D_CubeAxesDlg( getAction( GraduatedAxes ), this, "SPV3D_CubeAxesDlg" );
+ // myCubeAxesDlg->initialize();
+ // mySetRotationPointDlg = new SPV3D_SetRotationPointDlg
+ // ( getAction( ChangeRotationPointId ), this, "SPV3D_SetRotationPointDlg" );
+ // myViewParameterDlg = new SPV3D_ViewParameterDlg
+ // ( getAction( ViewParametersId ), this, "SPV3D_ViewParameterDlg" );
+
+ // myDefaultInteractorStyle = SPV3D_InteractorStyle::New();
+ // myInteractor->PushInteractorStyle(myDefaultInteractorStyle);
+ // myDefaultInteractorStyle->Delete();
+
+ // myRecorder = SPV3D_Recorder::New();
+
+ // myRecorder->SetNbFPS( 17.3 );
+ // myRecorder->SetQuality( 100 );
+ // myRecorder->SetProgressiveMode( true );
+ // myRecorder->SetUseSkippedFrames( true );
+ // myRecorder->SetRenderWindow( myInteractor->getRenderWindow() );
+
+ // setCentralWidget(myInteractor);
+
+ // myAxesWidget = salomevtk::vtkPVAxesWidget::New();
+ // myAxesWidget->SetParentRenderer(aRenderer->GetDevice());
+ // myAxesWidget->SetViewport(0, 0, 0.25, 0.25);
+ // myAxesWidget->SetInteractor(myInteractor->GetDevice());
+ // myAxesWidget->SetEnabled(1);
+ // myAxesWidget->SetInteractive(0);
+
+ // salomevtk::vtkPVAxesActor* anAxesActor = myAxesWidget->GetAxesActor();
+ // anAxesActor->GetXAxisTipProperty()->SetColor( 1.0, 0.0, 0.0 );
+ // anAxesActor->GetXAxisShaftProperty()->SetColor( 1.0, 0.0, 0.0 );
+ // anAxesActor->GetXAxisLabelProperty()->SetColor( 1.0, 0.0, 0.0 );
+ // anAxesActor->GetYAxisTipProperty()->SetColor( 0.0, 1.0, 0.0 );
+ // anAxesActor->GetYAxisShaftProperty()->SetColor( 0.0, 1.0, 0.0 );
+ // anAxesActor->GetYAxisLabelProperty()->SetColor( 0.0, 1.0, 0.0 );
+ // anAxesActor->GetZAxisTipProperty()->SetColor( 0.0, 0.0, 1.0 );
+ // anAxesActor->GetZAxisShaftProperty()->SetColor( 0.0, 0.0, 1.0 );
+ // anAxesActor->GetZAxisLabelProperty()->SetColor( 0.0, 0.0, 1.0 );
+
+ // myView = new SPV3D_View(this);
+ // Initialize(myView,theModel);
+
+
+// myEventCallbackCommand->SetClientData(this);
+// myEventCallbackCommand->SetCallback(SPV3D_ViewWindow::ProcessEvents);
+// myEventCallbackCommand->Delete();
+
+// GetInteractor()->GetInteractorStyle()->AddObserver(SPV3D::OperationFinished,
+// myEventCallbackCommand.GetPointer(), 0.0);
+// myKeyFreeInteractorStyle->AddObserver(SPV3D::OperationFinished,
+// myEventCallbackCommand.GetPointer(), 0.0);
+
+// #ifdef USE_WORKAROUND_FOR_MESA
+// char *mesavar = getenv("SALOME_USE_MESA");
+// if (mesavar)
+// getRenderer()->SetUseDepthPeeling(1);
+// #endif //USE_WORKAROUND_FOR_MESA
+
+// getRenderer()->SetBackgroundAlpha(1.0);
+// myInteractor->getRenderWindow()->SetMultiSamples(0);
+// myInteractor->getRenderWindow()->Render();
+// setBackground( Qtx::BackgroundData( Qt::black ) ); // set default background
+// onResetView();
+}
+
+/*!
+ To initialize #SPV3D_ViewWindow instance
+*/
+// void SPV3D_ViewWindow::Initialize(SPV3D_View* theView,
+// SPV3D_ViewModel/*Base*/* theModel)
+// {
+// DBG_FUN();
+// connect(theView,SIGNAL(KeyPressed(QKeyEvent*)),
+// this,SLOT(onKeyPressed(QKeyEvent*)) );
+// connect(theView,SIGNAL(KeyReleased(QKeyEvent*)),
+// this,SLOT(onKeyReleased(QKeyEvent*)));
+// connect(theView,SIGNAL(MouseButtonPressed(QMouseEvent*)),
+// this,SLOT(onMousePressed(QMouseEvent*)));
+// connect(theView,SIGNAL(MouseButtonReleased(QMouseEvent*)),
+// this,SLOT(onMouseReleased(QMouseEvent*)));
+// connect(theView,SIGNAL(MouseDoubleClicked(QMouseEvent*)),
+// this,SLOT(onMouseDoubleClicked(QMouseEvent*)));
+// connect(theView,SIGNAL(MouseMove(QMouseEvent*)),
+// this,SLOT(onMouseMoving(QMouseEvent*)));
+// connect(theView,SIGNAL(contextMenuRequested(QContextMenuEvent*)),
+// this,SIGNAL(contextMenuRequested(QContextMenuEvent *)));
+// // connect(theView,SIGNAL(selectionChanged()),
+// // theModel,SLOT(onSelectionChanged()));
+
+// // connect( this, SIGNAL( transformed( SPV3D_ViewWindow* ) ), SLOT( emitViewModified() ) );
+// }
+#endif
+
+/*!
+ Destructor
+*/
+SPV3D_ViewWindow::~SPV3D_ViewWindow()
+{
+ DBG_FUN();
+ // myRecorder->Delete();
+ // myAxesWidget->Delete();
+}
+
+
+/*!
+ \return corresponding view
+*/
+// SPV3D_View* SPV3D_ViewWindow::getView()
+// {
+// return myView;
+// }
+
+#if 0
+/*!
+ \return corresponding vtk render window
+*/
+vtkRenderWindow* SPV3D_ViewWindow::getRenderWindow()
+{
+ return GetInteractor()->getRenderWindow();
+}
+
+/*!
+ \return corresponding vtk render window interactor
+*/
+SPV3D_RenderWindowInteractor* SPV3D_ViewWindow::GetInteractor() const
+{
+ return myInteractor;
+}
+
+/*!
+ \return corresponding vtk render window interactor
+*/
+vtkRenderWindowInteractor* SPV3D_ViewWindow::getInteractor() const
+{
+ return myInteractor->GetDevice();
+}
+
+/*!
+ \return corresponding vtk renderer
+*/
+vtkRenderer* SPV3D_ViewWindow::getRenderer() const
+{
+ return GetInteractor()->getRenderer();
+}
+
+/*!
+ Redirect the request to SPV3D_RenderWindowInteractor::GetRenderer
+*/
+SPV3D_Renderer* SPV3D_ViewWindow::GetRenderer() const
+{
+ return GetInteractor()->GetRenderer();
+}
+#endif
+
+/*!
+ \return corresponding vtk selector
+*/
+// SPV3D_Selector* SPV3D_ViewWindow::GetSelector() const
+// {
+// return GetInteractor()->GetSelector();
+// }
+
+#if 0
+/*!
+ Processes transformation "front view"
+*/
+void SPV3D_ViewWindow::onFrontView()
+{
+ DBG_FUN();
+ GetRenderer()->OnFrontView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "back view"
+*/
+void SPV3D_ViewWindow::onBackView()
+{
+ DBG_FUN();
+ GetRenderer()->OnBackView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "top view"
+*/
+void SPV3D_ViewWindow::onTopView()
+{
+ DBG_FUN();
+ GetRenderer()->OnTopView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "bottom view"
+*/
+void SPV3D_ViewWindow::onBottomView()
+{
+ DBG_FUN();
+ GetRenderer()->OnBottomView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "left view"
+*/
+void SPV3D_ViewWindow::onLeftView()
+{
+ DBG_FUN();
+ GetRenderer()->OnLeftView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "right view"
+*/
+void SPV3D_ViewWindow::onRightView()
+{
+ DBG_FUN();
+ GetRenderer()->OnRightView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ \brief Rotate view 90 degrees clockwise
+*/
+void SPV3D_ViewWindow::onClockWiseView()
+{
+ DBG_FUN();
+ GetRenderer()->onClockWiseView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ \brief Rotate view 90 degrees conterclockwise
+*/
+void SPV3D_ViewWindow::onAntiClockWiseView()
+{
+ DBG_FUN();
+ GetRenderer()->onAntiClockWiseView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "reset view": sets default orientation of viewport camera
+*/
+void SPV3D_ViewWindow::onResetView()
+{
+ DBG_FUN();
+ GetRenderer()->OnResetView();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "fit all"
+*/
+void SPV3D_ViewWindow::onFitAll()
+{
+ DBG_FUN();
+ GetRenderer()->OnFitAll();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "fit selection"
+*/
+void SPV3D_ViewWindow::onFitSelection()
+{
+ DBG_FUN();
+ GetRenderer()->onFitSelection();
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Processes transformation "fit given objects"
+*/
+void SPV3D_ViewWindow::onFitIObjects(const SALOME_ListIO& objects)
+{
+ DBG_FUN();
+ GetRenderer()->OnFitIObjects(objects);
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ SLOT: called if selection is changed
+*/
+void SPV3D_ViewWindow::onSelectionChanged()
+{
+ DBG_FUN();
+ myView->onSelectionChanged();
+}
+
+/*!
+ Change selection mode
+ \param theMode - new selection mode
+*/
+void SPV3D_ViewWindow::SetSelectionMode(Selection_Mode theMode)
+{
+ DBG_FUN();
+ GetSelector()->SetSelectionMode(theMode);
+}
+
+/*!
+ \return selection mode
+*/
+Selection_Mode SPV3D_ViewWindow::SelectionMode() const
+{
+ return GetSelector()->SelectionMode();
+}
+
+/*!
+ Unhilights all objects in viewer
+*/
+void SPV3D_ViewWindow::unHighlightAll()
+{
+ myView->unHighlightAll();
+}
+
+/*!
+ Hilights/unhilights object in viewer
+ \param theIO - object to be updated
+ \param theIsHighlight - if it is true, object will be hilighted, otherwise it will be unhilighted
+ \param theIsUpdate - update current viewer
+*/
+void SPV3D_ViewWindow::highlight(const Handle(SALOME_InteractiveObject)& theIO,
+ bool theIsHighlight,
+ bool theIsUpdate )
+{
+ myView->highlight( theIO, theIsHighlight, theIsUpdate );
+}
+
+/*!
+ \return true if object is in viewer or in collector
+ \param theIO - object to be checked
+*/
+bool SPV3D_ViewWindow::isInViewer( const Handle(SALOME_InteractiveObject)& theIO )
+{
+ return myView->isInViewer( theIO );
+}
+#endif
+
+#if 0
+/*!
+ \return true if object is displayed in viewer
+ \param theIO - object to be checked
+*/
+bool SPV3D_ViewWindow::isVisible( const Handle(SALOME_InteractiveObject)& theIO )
+{
+ return myView->isVisible( theIO );
+}
+
+/*!
+ Display object
+ \param theEntry - entry that corresponds to intractive objects
+*/
+Handle(SALOME_InteractiveObject) SPV3D_ViewWindow::FindIObject(const char* theEntry)
+{
+ return myView->FindIObject(theEntry);
+}
+#endif
+
+/*!
+ Display object
+ \param theIO - object
+ \param theImmediatly - update viewer
+*/
+void SPV3D_ViewWindow::Display(const Handle(SALOME_InteractiveObject)& theIO,
+ bool theImmediatly)
+{
+ DBG_FUN();
+ //myView->Display(theIO,theImmediatly);
+}
+
+/*!
+ Erase object
+ \param theIO - object
+ \param theImmediatly - update viewer
+*/
+void SPV3D_ViewWindow::Erase(const Handle(SALOME_InteractiveObject)& theIO,
+ bool theImmediatly)
+{
+ DBG_FUN();
+ //myView->Erase(theIO,theImmediatly);
+}
+
+/*!
+ Display only passed object
+ \param theIO - object
+*/
+void SPV3D_ViewWindow::DisplayOnly(const Handle(SALOME_InteractiveObject)& theIO)
+{
+ DBG_FUN();
+ //myView->DisplayOnly(theIO);
+}
+
+/*!
+ Display all objects in view
+*/
+void SPV3D_ViewWindow::DisplayAll()
+{
+ DBG_FUN();
+ //myView->DisplayAll();
+}
+
+/*!
+ Erase all objects in view
+*/
+void SPV3D_ViewWindow::EraseAll()
+{
+ DBG_FUN();
+ //myView->EraseAll();
+}
+
+#if 0
+/*!
+ Sets background color [obsolete]
+ \param color - new background color
+*/
+void SPV3D_ViewWindow::setBackgroundColor( const QColor& c )
+{
+ DBG_FUN();
+ Qtx::BackgroundData bg = background();
+ bg.setColor( c );
+ setBackground( bg );
+}
+
+/*!
+ \return background color of viewer [obsolete]
+*/
+QColor SPV3D_ViewWindow::backgroundColor() const
+{
+ return background().color();
+}
+
+/*!
+ Sets background data
+ \param bgData - new background data
+*/
+void SPV3D_ViewWindow::setBackground( const Qtx::BackgroundData& bgData )
+{
+ DBG_FUN();
+ bool ok = false;
+
+ if ( bgData.isValid() ) {
+ switch ( bgData.mode() ) {
+ case Qtx::ColorBackground:
+ {
+ QColor c = bgData.color();
+ if ( c.isValid() ) {
+ // show solid-colored background
+ getRenderer()->SetTexturedBackground( false ); // cancel texture mode
+ getRenderer()->SetGradientBackground( false ); // cancel gradient mode
+ getRenderer()->SetBackground( c.red()/255.0,
+ c.green()/255.0,
+ c.blue()/255.0 ); // set background color
+ ok = true;
+ }
+ break;
+ }
+ case Qtx::SimpleGradientBackground:
+ {
+ QColor c1, c2;
+ int type = bgData.gradient( c1, c2 );
+ if ( c1.isValid() )
+ {
+ if ( !c2.isValid() )
+ c2 = c1;
+
+ // show two-color gradient background
+ getRenderer()->SetTexturedBackground( false ); // cancel texture mode
+ getRenderer()->SetGradientBackground( true ); // switch to gradient mode
+
+ PV3DViewer_OpenGLRenderer* aRenderer =
+ PV3DViewer_OpenGLRenderer::SafeDownCast( getRenderer() );
+ if( aRenderer )
+ {
+ aRenderer->SetGradientType( type );
+ aRenderer->SetBackground( c1.redF(), c1.greenF(), c1.blueF() );
+ aRenderer->SetBackground2( c2.redF(), c2.greenF(), c2.blueF() );
+ ok = true;
+ }
+ }
+ break;
+ }
+ case Qtx::CustomGradientBackground:
+ {
+ // NOT IMPLEMENTED YET
+ getRenderer()->SetTexturedBackground( false ); // cancel texture mode
+ getRenderer()->SetGradientBackground( false ); // cancel gradient mode
+ // .........
+ break;
+ }
+ default:
+ break;
+ }
+ if ( bgData.isTextureShown() ) {
+ QString fileName;
+ int textureMode = bgData.texture( fileName );
+ QFileInfo fi( fileName );
+ if ( !fileName.isEmpty() && fi.exists() ) {
+ // read texture from file
+ QString extension = fi.suffix().toLower();
+ vtkImageReader2* aReader = 0;
+ if ( extension == "jpg" || extension == "jpeg" )
+ aReader = vtkJPEGReader::New();
+ else if ( extension == "bmp" )
+ aReader = vtkBMPReader::New();
+ else if ( extension == "tif" || extension == "tiff" )
+ aReader = vtkTIFFReader::New();
+ else if ( extension == "png" )
+ aReader = vtkPNGReader::New();
+ else if ( extension == "mhd" || extension == "mha" )
+ aReader = vtkMetaImageReader::New();
+ if ( aReader ) {
+ // create texture
+ aReader->SetFileName( fi.absoluteFilePath().toUtf8().constData() );
+ aReader->Update();
+ PV3DViewer_Texture* aTexture = PV3DViewer_Texture::New();
+ vtkImageMapToColors* aMap = 0;
+ vtkAlgorithmOutput* anOutput;
+ /*
+ // special processing for BMP reader
+ vtkBMPReader* aBMPReader = (vtkBMPReader*)aReader;
+ if ( aBMPReader ) {
+ // Special processing for BMP file
+ aBMPReader->SetAllow8BitBMP(1);
+
+ aMap = vtkImageMapToColors::New();
+ aMap->SetInputConnection( aBMPReader->GetOutputPort() );
+ aMap->SetLookupTable( (vtkScalarsToColors*)aBMPReader->GetLookupTable() );
+ aMap->SetOutputFormatToRGB();
+
+ anOutput = aMap->GetOutputPort();
+ }
+ else {
+ }
+ */
+ anOutput = aReader->GetOutputPort( 0 );
+ aTexture->SetInputConnection( anOutput );
+ // set texture mode
+ // VSR: Currently, PV3D only supports Stretch mode, so below code will give
+ // the same results for all modes
+ switch ( textureMode ) {
+ case Qtx::TileTexture:
+ aTexture->SetPosition((int)PV3DViewer_Texture::Tiled);
+ break;
+ case Qtx::StretchTexture:
+ aTexture->SetPosition((int)PV3DViewer_Texture::Stretched);
+ break;
+ case Qtx::CenterTexture:
+ aTexture->SetPosition((int)PV3DViewer_Texture::Centered);
+ default:
+ break;
+ }
+ // show textured background
+ getRenderer()->SetTexturedBackground( true );
+ getRenderer()->SetBackgroundTexture( aTexture );
+
+ // clean-up resources
+ if ( aMap )
+ aMap->Delete();
+ aReader->Delete();
+ aTexture->Delete();
+ ok = true;
+ }
+ }
+ }
+ }
+ if ( ok )
+ myBackground = bgData;
+}
+
+/*!
+ \return background data of viewer
+*/
+Qtx::BackgroundData SPV3D_ViewWindow::background() const
+{
+ return myBackground;
+}
+
+
+/*!
+ Redirect the request to SPV3D_RenderWindowInteractor::GetInteractorStyle
+*/
+vtkInteractorStyle* SPV3D_ViewWindow::GetInteractorStyle() const
+{
+ return GetInteractor()->GetInteractorStyle();
+}
+
+/*!
+ Redirect the request to SPV3D_RenderWindowInteractor::PushInteractorStyle
+*/
+void SPV3D_ViewWindow::PushInteractorStyle(vtkInteractorStyle* theStyle)
+{
+ GetInteractor()->PushInteractorStyle(theStyle);
+}
+
+/*!
+ Redirect the request to SPV3D_RenderWindowInteractor::PopInteractorStyle
+*/
+void SPV3D_ViewWindow::PopInteractorStyle()
+{
+ GetInteractor()->PopInteractorStyle();
+}
+#endif
+
+/*!
+ Updates current viewer
+*/
+void SPV3D_ViewWindow::Repaint(bool )//(bool theUpdateTrihedron)
+{
+// if(theUpdateTrihedron)
+// GetRenderer()->OnAdjustTrihedron();
+
+// GetInteractor()->update();
+
+// SPV3D_InteractorStyle* aStyle = (SPV3D_InteractorStyle*)getInteractor()->GetInteractorStyle();
+// if ( aStyle ) {
+// #ifdef VGL_WORKAROUND
+// if ( aStyle->GetCurrentRenderer() == nullptr ) {
+// if( GetRenderer() ) {
+// aStyle->SetCurrentRenderer(GetRenderer()->GetDevice());
+// }
+// }
+// #endif
+// aStyle->OnTimer();
+// }
+}
+
+#if 0
+/*!
+ Redirect the request to #SPV3D_Renderer::GetScale
+*/
+void SPV3D_ViewWindow::GetScale( double theScale[3] )
+{
+ GetRenderer()->GetScale( theScale );
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::SetScale
+*/
+void SPV3D_ViewWindow::SetScale( double theScale[3] )
+{
+ GetRenderer()->SetScale( theScale );
+ Repaint();
+ emit transformed( this );
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::IsTrihedronDisplayed
+*/
+bool SPV3D_ViewWindow::isTrihedronDisplayed()
+{
+ return GetRenderer()->IsTrihedronDisplayed();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::IsCubeAxesDisplayed
+*/
+bool SPV3D_ViewWindow::isCubeAxesDisplayed()
+{
+ return GetRenderer()->IsCubeAxesDisplayed();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::OnViewTrihedron
+*/
+void SPV3D_ViewWindow::onViewTrihedron(bool show)
+{
+ DBG_FUN();
+ GetRenderer()->SetTrihedronVisibility(show);
+ Repaint();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::OnViewCubeAxes
+*/
+void SPV3D_ViewWindow::onViewCubeAxes()
+{
+ GetRenderer()->OnViewCubeAxes();
+ Repaint();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::GetTrihedron
+*/
+PV3DViewer_Trihedron* SPV3D_ViewWindow::GetTrihedron()
+{
+ return GetRenderer()->GetTrihedron();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::GetCubeAxes
+*/
+SPV3D_CubeAxesActor2D* SPV3D_ViewWindow::GetCubeAxes()
+{
+ return GetRenderer()->GetCubeAxes();
+}
+
+/*!
+ \return trihedron size
+*/
+double SPV3D_ViewWindow::GetTrihedronSize() const
+{
+ return GetRenderer()->GetTrihedronSize();
+}
+
+/*!
+ Sets projection mode
+ \param theMode - projection mode ( 0 - orthogonal, 1 - perspective, 2 - stereo )
+*/
+void SPV3D_ViewWindow::SetProjectionMode(const int theMode)
+{
+ DBG_FUN();
+ QtxAction* aParallelAction = dynamic_cast<QtxAction*>( toolMgr()->action( ParallelModeId ) );
+ QtxAction* aProjectionAction = dynamic_cast<QtxAction*>( toolMgr()->action( ProjectionModeId ) );
+ QtxAction* aStereoAction = dynamic_cast<QtxAction*>( toolMgr()->action( StereoModeId ) );
+
+ switch ( theMode ) {
+ case Parallel:
+ onProjectionMode( aParallelAction );
+ break;
+ case Projection:
+ onProjectionMode( aProjectionAction );
+ break;
+ case Stereo:
+ onStereoMode( true );
+ break;
+ }
+
+ // update action state if method is called outside
+ SPV3D_Viewer* aViewer = dynamic_cast<SPV3D_Viewer*>(myModel);
+ QtxAction* aSwitchZoomingStyle = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchZoomingStyleId ) );
+ if ( theMode == Parallel && !aParallelAction->isChecked() ) {
+ aParallelAction->setChecked( true );
+ aSwitchZoomingStyle->setEnabled(true);
+ aStereoAction->setChecked( false );
+ }
+ if ( theMode == Projection && !aProjectionAction->isChecked() ) {
+ aProjectionAction->setChecked( true );
+ aSwitchZoomingStyle->setEnabled(false);
+ }
+ if ( theMode == Stereo ) {
+ aStereoAction->setChecked( true );
+ if ( aParallelAction->isEnabled() ) {
+ aParallelAction->setEnabled( false );
+ aParallelAction->setChecked( false );
+ aStereoAction->setChecked( false );
+ }
+ else {
+ aParallelAction->setEnabled( true );
+ aStereoAction->setChecked( false );
+ aParallelAction->setChecked( aViewer->projectionMode() == Parallel );
+ }
+ if ( aProjectionAction->isEnabled() ) {
+ aProjectionAction->setEnabled( false );
+ aProjectionAction->setChecked( true );
+ if ( getRenderWindow()->GetStereoCapableWindow() == 1 && !isOpenGlStereoSupport() &&
+ strcmp( "CrystalEyes", getRenderWindow()->GetStereoTypeAsString() ) == 0 &&
+ toolMgr()->action( StereoModeId )->isChecked() ) {
+ SUIT_MessageBox::warning( 0, tr( "WRN_WARNING" ), tr( "WRN_SUPPORT_QUAD_BUFFER" ) );
+ }
+ }
+ else {
+ aProjectionAction->setEnabled( true );
+ aStereoAction->setChecked( false );
+ aProjectionAction->setChecked( aViewer->projectionMode() == Projection );
+ onProjectionMode();
+ }
+ }
+ else {
+ if ( !aParallelAction->isEnabled() )
+ aParallelAction->setEnabled( true );
+ if ( !aProjectionAction->isEnabled() )
+ aProjectionAction->setEnabled( true );
+ }
+}
+
+/*!
+ Sets stereo type
+ \param theType - stereo type
+*/
+void SPV3D_ViewWindow::SetStereoType(const int theType)
+{
+ DBG_FUN();
+ vtkRenderWindow* aWindow = getRenderWindow();
+ switch (theType ) {
+ case CrystalEyes:
+ aWindow->SetStereoTypeToCrystalEyes();
+ break;
+ case RedBlue:
+ aWindow->SetStereoTypeToRedBlue();
+ break;
+ case Interlaced:
+ aWindow->SetStereoTypeToInterlaced();
+ break;
+ case Left:
+ aWindow->SetStereoTypeToLeft();
+ break;
+ case Right:
+ aWindow->SetStereoTypeToRight();
+ break;
+ case Dresden:
+ aWindow->SetStereoTypeToDresden();
+ break;
+ case Anaglyph:
+ aWindow->SetStereoTypeToAnaglyph();
+ break;
+ case Checkerboard:
+ aWindow->SetStereoTypeToCheckerboard();
+ break;
+ case SplitViewPortHorizontal:
+ aWindow->SetStereoTypeToSplitViewportHorizontal();
+ break;
+ }
+}
+
+/*!
+ Sets anaglyph filter
+ \param theFilter - anaglyph filter
+*/
+void SPV3D_ViewWindow::SetAnaglyphFilter(const int theFilter)
+{
+ DBG_FUN();
+ vtkRenderWindow* aWindow = getRenderWindow();
+ switch (theFilter ) {
+ case RedCyan:
+ aWindow->SetAnaglyphColorMask(4,3);
+ break;
+ case YellowBlue:
+ aWindow->SetAnaglyphColorMask(6,1);
+ break;
+ case GreenMagenta:
+ aWindow->SetAnaglyphColorMask(2,5);
+ break;
+ }
+}
+
+/*!
+ Set support quad-buffered stereo
+ \param theEnable - enable/disable support quad-buffered stereo
+*/
+void SPV3D_ViewWindow::SetQuadBufferSupport(const bool theEnable)
+{
+ DBG_FUN();
+ vtkRenderWindow* aWindow = getRenderWindow();
+ aWindow->SetStereoCapableWindow((int)theEnable);
+}
+
+/*!
+ \return OpenGl stereo support
+*/
+bool SPV3D_ViewWindow::isOpenGlStereoSupport() const
+{
+ GLboolean support[1];
+ glGetBooleanv (GL_STEREO, support);
+ if ( support[0] )
+ return true;
+ return false;
+}
+
+/*!
+ Set the gravity center as a focal point
+*/
+void SPV3D_ViewWindow::activateSetFocalPointGravity()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::SetFocalPointGravity, 0);
+}
+
+/*!
+ Activate interactive selection
+*/
+void SPV3D_ViewWindow::activateInteractiveSelection()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartInteractiveSelection, 0);
+}
+
+/*
+ Deactivate current active operation
+*/
+void SPV3D_ViewWindow::deactivateCurrectOperation() {
+ myEventDispatcher->InvokeEvent(SPV3D::StopCurrentOperation, 0);
+}
+
+/*!
+ Set the selected point as a focal point
+*/
+void SPV3D_ViewWindow::activateSetFocalPointSelected()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::SetFocalPointSelected, 0);
+}
+
+/*!
+ Set the point selected by user as a focal point
+*/
+void SPV3D_ViewWindow::activateStartFocalPointSelection()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartFocalPointSelection,0);
+}
+
+void SPV3D_ViewWindow::activateProjectionMode(int theMode)
+{
+ QtxAction* aParallelAction = dynamic_cast<QtxAction*>( toolMgr()->action( ParallelModeId ) );
+ QtxAction* aProjectionAction = dynamic_cast<QtxAction*>( toolMgr()->action( ProjectionModeId ) );
+ if (theMode)
+ aParallelAction->setChecked( true );
+ else
+ aProjectionAction->setChecked( true );
+
+ if ( !aParallelAction->isEnabled() )
+ aParallelAction->setEnabled( true );
+ if ( !aProjectionAction->isEnabled() )
+ aProjectionAction->setEnabled( true );
+}
+
+/*!
+ Sets actual interaction style
+ \param theStyle - type of interaction style ( 0 - standard, 1 - keyboard free )
+*/
+void SPV3D_ViewWindow::SetInteractionStyle(const int theStyle)
+{
+ DBG_FUN();
+ onSwitchInteractionStyle( theStyle==1 );
+}
+
+/*!
+ Sets actual zooming style
+ \param theStyle - type of zooming style ( 0 - standard, 1 - advanced (at cursor) )
+*/
+void SPV3D_ViewWindow::SetZoomingStyle(const int theStyle)
+{
+ DBG_FUN();
+ onSwitchZoomingStyle( theStyle==1 );
+}
+
+/*!
+ Set preselection mode.
+ \param theMode the mode to set (standard, dynamic or disabled)
+*/
+void SPV3D_ViewWindow::SetPreSelectionMode( Preselection_Mode theMode )
+{
+ DBG_FUN();
+ onSwitchPreSelectionMode( theMode );
+}
+#endif
+
+/*!
+ Enables/disables selection.
+ \param theEnable if true - selection will be enabled
+*/
+void SPV3D_ViewWindow::SetSelectionEnabled( bool theEnable )
+{
+ DBG_FUN();
+ // GetSelector()->SetSelectionEnabled( theEnable );
+ // QtxAction* a = getAction( EnableSelectionId );
+ // if ( a->isChecked() != theEnable)
+ // a->setChecked( theEnable );
+ // QtxActionGroup* aPreselectionGroup =
+ // dynamic_cast<QtxActionGroup*>( getAction( PreselectionId ) );
+ // if ( aPreselectionGroup )
+ // aPreselectionGroup->setEnabled( theEnable );
+
+ // // notify actors
+ // vtkActorCollection *actors = getRenderer()->GetActors();
+ // for (int i = 0; i < actors->GetNumberOfItems(); ++i )
+ // if (PV3DViewer_Actor *actor = dynamic_cast<PV3DViewer_Actor*>(actors->GetItemAsObject(i)))
+ // {
+ // actor->EnableSelection( theEnable );
+ // }
+}
+
+#if 0
+/*!
+ Switches "keyboard free" interaction style on/off
+*/
+void SPV3D_ViewWindow::onSwitchInteractionStyle(bool theOn)
+{
+ DBG_FUN();
+ if (theOn) {
+ // check if style is already set
+ if ( GetInteractorStyle() != myKeyFreeInteractorStyle.GetPointer() )
+ {
+ // keep the same style extensions
+ SPV3D_InteractorStyle* aStyle = (SPV3D_InteractorStyle*)GetInteractorStyle();
+ if ( aStyle ) {
+ myKeyFreeInteractorStyle->SetControllerIncrement(aStyle->ControllerIncrement());
+ myKeyFreeInteractorStyle->SetControllerOnKeyDown(aStyle->ControllerOnKeyDown());
+ }
+
+ PushInteractorStyle(myKeyFreeInteractorStyle.GetPointer());
+ }
+ }
+ else {
+ // pop only key free style
+ if ( GetInteractorStyle() == myKeyFreeInteractorStyle.GetPointer() )
+ PopInteractorStyle();
+ }
+
+ // update action state if method is called outside
+ QtxAction* a = getAction( SwitchInteractionStyleId );
+ if ( a->isChecked() != theOn ) a->setChecked( theOn );
+}
+
+/*!
+ Toogles advanced zooming style (relatively to the cursor position) on/off
+*/
+void SPV3D_ViewWindow::onSwitchZoomingStyle( bool theOn )
+{
+ DBG_FUN();
+ if( myDefaultInteractorStyle.GetPointer() )
+ myDefaultInteractorStyle->SetAdvancedZoomingEnabled( theOn );
+ if( myKeyFreeInteractorStyle.GetPointer() )
+ myKeyFreeInteractorStyle->SetAdvancedZoomingEnabled( theOn );
+
+ // update action state if method is called outside
+ QtxAction* a = getAction( SwitchZoomingStyleId );
+ if ( a->isChecked() != theOn )
+ a->setChecked( theOn );
+}
+
+/*!
+ Switch preselection mode.
+ \param theMode the preselection mode
+*/
+void SPV3D_ViewWindow::onSwitchPreSelectionMode( int theMode )
+{
+ DBG_FUN();
+ GetSelector()->SetDynamicPreSelection( theMode == Dynamic_Preselection );
+ GetSelector()->SetPreSelectionEnabled( theMode != Preselection_Disabled );
+
+ // update action state if method is called outside
+ QtxAction* a = getAction( StandardPreselectionId + theMode );
+ if ( a && !a->isChecked() )
+ a->setChecked( true );
+}
+
+/*!
+ Enables/disables selection.
+ \param theOn if true - selection will be enabled
+*/
+void SPV3D_ViewWindow::onEnableSelection( bool on )
+{
+ DBG_FUN();
+ SPV3D_Viewer* aViewer = dynamic_cast<SPV3D_Viewer*>(myModel);
+ if(aViewer)
+ aViewer->enableSelection(on);
+}
+
+/*!
+ Sets incremental speed
+ \param theValue - new incremental speed
+ \param theMode - modification mode
+*/
+void SPV3D_ViewWindow::SetIncrementalSpeed(const int theValue, const int theMode)
+{
+ DBG_FUN();
+ if ( (SPV3D_InteractorStyle*)GetInteractorStyle() )
+ ((SPV3D_InteractorStyle*)GetInteractorStyle())->SetIncrementSpeed(theValue, theMode);
+}
+
+/*!
+ Sets spacemouse buttons for the functions
+ \param theBtn1 - spacemouse button for the "decrease speed increment"
+ \param theBtn2 - spacemouse button for the "increase speed increment"
+ \param theBtn3 - spacemouse button for the "dominant combined switch"
+*/
+void SPV3D_ViewWindow::SetSpacemouseButtons(const int theBtn1,
+ const int theBtn2,
+ const int theBtn3)
+{
+ DBG_FUN();
+ int val = theBtn1;
+ myEventDispatcher->InvokeEvent(SPV3D::SetSMDecreaseSpeedEvent, &val);
+ val = theBtn2;
+ myEventDispatcher->InvokeEvent(SPV3D::SetSMIncreaseSpeedEvent, &val);
+ val = theBtn3;
+ myEventDispatcher->InvokeEvent(SPV3D::SetSMDominantCombinedSwitchEvent, &val);
+}
+
+/*!
+ Sets trihedron size
+ \param theSize - new trihedron size
+ \param theRelative - trihedron relativeness
+*/
+void SPV3D_ViewWindow::SetTrihedronSize(const double theSize, const bool theRelative)
+{
+ GetRenderer()->SetTrihedronSize(theSize, theRelative);
+ Repaint();
+}
+
+/*! If parameter theIsForcedUpdate is true, recalculate parameters for
+ * trihedron and cube axes, even if trihedron and cube axes is invisible.
+ */
+void SPV3D_ViewWindow::AdjustTrihedrons(const bool /*theIsForcedUpdate*/)
+{
+ GetRenderer()->AdjustActors();
+ Repaint();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::OnAdjustTrihedron
+*/
+void SPV3D_ViewWindow::onAdjustTrihedron()
+{
+ GetRenderer()->OnAdjustTrihedron();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::OnAdjustCubeAxes
+*/
+void SPV3D_ViewWindow::onAdjustCubeAxes()
+{
+ GetRenderer()->OnAdjustCubeAxes();
+}
+
+void SPV3D_ViewWindow::synchronize(SPV3D_ViewWindow* otherViewWindow )
+{
+ DBG_FUN();
+ if ( otherViewWindow ) {
+ bool blocked = blockSignals( true );
+ doSetVisualParameters( otherViewWindow->getVisualParameters(), true );
+ blockSignals( blocked );
+ }
+}
+#endif
+
+/*!
+ Emits key pressed
+*/
+void SPV3D_ViewWindow::onKeyPressed(QKeyEvent* event)
+{
+ emit keyPressed( this, event );
+}
+
+/*!
+ Emits key released
+*/
+void SPV3D_ViewWindow::onKeyReleased(QKeyEvent* event)
+{
+ emit keyReleased( this, event );
+}
+
+/*!
+ Emits mouse pressed
+*/
+void SPV3D_ViewWindow::onMousePressed(QMouseEvent* event)
+{
+ emit mousePressed(this, event);
+}
+
+/*!
+ Emits mouse released
+*/
+void SPV3D_ViewWindow::onMouseReleased(QMouseEvent* event)
+{
+ DBG_FUN();
+ emit mouseReleased( this, event );
+}
+
+/*!
+ Emits mouse moving
+*/
+void SPV3D_ViewWindow::onMouseMoving(QMouseEvent* event)
+{
+ emit mouseMoving( this, event );
+}
+
+/*!
+ Emits mouse double clicked
+*/
+void SPV3D_ViewWindow::onMouseDoubleClicked( QMouseEvent* event )
+{
+ MSGEL("-----> emit mouseDoubleClicked <-----");
+ emit mouseDoubleClicked( this, event );
+}
+
+#if 0
+/*!
+ Redirect the request to #SPV3D_Renderer::AddActor
+*/
+void SPV3D_ViewWindow::AddActor( PV3DViewer_Actor* theActor,
+ bool theUpdate,
+ bool theIsAdjustActors )
+{
+ DBG_FUN();
+ GetRenderer()->AddActor(theActor, theIsAdjustActors);
+ if(theUpdate)
+ Repaint();
+ emit actorAdded(theActor);
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::RemoveActor
+*/
+void SPV3D_ViewWindow::RemoveActor( PV3DViewer_Actor* theActor,
+ bool theUpdate,
+ bool theIsAdjustActors )
+{
+ DBG_FUN();
+ GetRenderer()->RemoveActor(theActor, theIsAdjustActors);
+ if ( myDefaultInteractorStyle )
+ myDefaultInteractorStyle->FreeActors();
+ if ( myKeyFreeInteractorStyle )
+ myKeyFreeInteractorStyle->FreeActors();
+ if(theUpdate)
+ Repaint();
+ emit actorRemoved(theActor);
+}
+
+QImage SPV3D_ViewWindow::dumpViewContent()
+{
+ vtkRenderWindow* aWindow = getRenderWindow();
+ int* aSize = aWindow->GetSize();
+ int aWidth = aSize[0];
+ int aHeight = aSize[1];
+
+#ifndef DISABLE_GLVIEWER
+ OpenGLUtils_FrameBuffer aFrameBuffer;
+ if( aFrameBuffer.init( aWidth, aHeight ) )
+ {
+ glPushAttrib( GL_VIEWPORT_BIT );
+ glViewport( 0, 0, aWidth, aHeight );
+ aFrameBuffer.bind();
+
+ // draw scene
+ aWindow->Render();
+
+ //aFrameBuffer.unbind();
+ glPopAttrib();
+
+ QImage anImage( aWidth, aHeight, QImage::Format_RGB32 );
+ //aFrameBuffer.bind();
+
+ glReadPixels( 0, 0, aWidth, aHeight, GL_RGBA, GL_UNSIGNED_BYTE, anImage.bits() );
+ aFrameBuffer.unbind();
+
+ anImage = anImage.rgbSwapped();
+ anImage = anImage.mirrored();
+ return anImage;
+ }
+#endif
+
+ // if frame buffers are unsupported, use old functionality
+ unsigned char *aData =
+ aWindow->GetRGBACharPixelData( 0, 0, aWidth-1, aHeight-1, 0 );
+
+ QImage anImage( aData, aWidth, aHeight, QImage::Format_ARGB32 );
+
+ anImage = anImage.rgbSwapped();
+ anImage = anImage.mirrored();
+ return anImage;
+}
+
+/*!
+ \return QImage, containing all scene rendering in window
+*/
+QImage SPV3D_ViewWindow::dumpView()
+{
+ if( myDumpImage.isNull() )
+ return dumpViewContent();
+
+ RefreshDumpImage();
+ return myDumpImage;
+}
+
+QString SPV3D_ViewWindow::filter() const
+{
+ return tr( "SPV3D_IMAGE_FILES" );
+}
+
+bool SPV3D_ViewWindow::dumpViewToFormat( const QImage& img, const QString& fileName, const QString& format )
+{
+ if ( format != "PS" && format != "EPS" && format != "PDF" )
+ return SUIT_ViewWindow::dumpViewToFormat( img, fileName, format );
+
+ SPV3D_PsOptionsDlg* optionsDlg = new SPV3D_PsOptionsDlg(this);
+ if ( optionsDlg->exec() == QDialog::Accepted ) {
+ SUIT_OverrideCursor wc;
+
+ vtkGL2PSExporter *anExporter = vtkGL2PSExporter::New();
+ anExporter->SetRenderWindow(getRenderWindow());
+
+ // Set options
+ anExporter->SetLineWidthFactor(optionsDlg->getLineFactor());
+ anExporter->SetPointSizeFactor(optionsDlg->getPointFactor());
+ anExporter->SetSort((vtkGL2PSExporter::SortScheme)optionsDlg->getSortType());
+ anExporter->SetWrite3DPropsAsRasterImage((int)optionsDlg->isRasterize3D());
+ anExporter->SetPS3Shading((int)optionsDlg->isPs3Shading());
+
+ if ( format == "PS" ) {
+ anExporter->SetFileFormatToPS();
+ anExporter->CompressOff();
+ }
+
+ if ( format == "EPS" ) {
+ anExporter->SetFileFormatToEPS();
+ anExporter->CompressOff();
+ }
+
+ if ( format == "PDF" ) {
+ anExporter->SetFileFormatToPDF();
+ }
+
+ QString aFilePrefix(fileName);
+ QString anExtension(SUIT_Tools::extension(fileName));
+ aFilePrefix.truncate(aFilePrefix.length() - 1 - anExtension.length());
+ anExporter->SetFilePrefix(aFilePrefix.toUtf8().data());
+ anExporter->Write();
+ anExporter->Delete();
+ }
+ delete optionsDlg;
+ return true;
+}
+
+/*!
+ \refresh QImage, containing all scene rendering in window
+*/
+void SPV3D_ViewWindow::RefreshDumpImage()
+{
+ myDumpImage = dumpViewContent();
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::SetSelectionProp
+*/
+void SPV3D_ViewWindow::SetSelectionProp(const double& theRed,
+ const double& theGreen,
+ const double& theBlue,
+ const int& theWidth)
+{
+ myView->SetSelectionProp(theRed,theGreen,theBlue,theWidth);
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::SetSelectionProp
+*/
+void SPV3D_ViewWindow::SetPreselectionProp(const double& theRed,
+ const double& theGreen,
+ const double& theBlue,
+ const int& theWidth)
+{
+ myView->SetPreselectionProp(theRed,theGreen,theBlue,theWidth);
+}
+
+/*!
+ Redirect the request to #SPV3D_Renderer::SetSelectionTolerance
+*/
+void SPV3D_ViewWindow::SetSelectionTolerance(const double& theTolNodes,
+ const double& theTolItems,
+ const double& theTolObjects)
+{
+ myView->SetSelectionTolerance(theTolNodes, theTolItems, theTolObjects);
+}
+
+/*!
+ Get visibility status of the static trihedron
+*/
+bool SPV3D_ViewWindow::IsStaticTrihedronVisible() const
+{
+ return (bool)myAxesWidget->GetEnabled();
+}
+
+/*!
+ Set visibility status of the static trihedron
+*/
+void SPV3D_ViewWindow::SetStaticTrihedronVisible( const bool theIsVisible )
+{
+ myAxesWidget->SetEnabled( (int)theIsVisible );
+}
+
+/*!
+ Performs action
+ \param accelAction - action
+*/
+bool SPV3D_ViewWindow::action( const int accelAction )
+{
+ if ( accelAction == SUIT_Accel::ZoomFit )
+ onFitAll();
+ else {
+ int anEvent = SPV3D::convertAction( accelAction );
+ GetInteractor()->InvokeEvent(anEvent, 0);
+ }
+ return true;
+}
+
+/*!
+ \return action by it's id
+*/
+QtxAction* SPV3D_ViewWindow::getAction( int id ) const
+{
+ return dynamic_cast<QtxAction*>( toolMgr()->action( id ) );
+}
+
+
+// old visual parameters had 13 values. New format added additional
+// 76 values for graduated axes, so both numbers are processed.
+const int nNormalParams = 13; // number of view windows parameters excluding graduated axes params
+const int nGradAxisParams = 25; // number of parameters of ONE graduated axis (X, Y, or Z)
+const int nTrihedronParams = 3; // number of parameters for Trihedron
+const int nAllParams = nNormalParams + 3*nGradAxisParams + nTrihedronParams + 1; // number of all visual parameters
+
+/*! The method returns visual parameters of a graduated axis actor (x,y,z axis of graduated axes)
+ */
+void getGradAxisVisualParams( QXmlStreamWriter& writer, vtkAxisActor2D* actor, QString theAxis )
+{
+ //QString params;
+ if ( !actor )
+ return ;//params;
+
+ // Name
+ bool isVisible = actor->GetTitleVisibility();
+ QString title ( actor->GetTitle() );
+ double color[ 3 ];
+ int font = PV3D_ARIAL;
+ int bold = 0;
+ int italic = 0;
+ int shadow = 0;
+
+ vtkTextProperty* txtProp = actor->GetTitleTextProperty();
+ if ( txtProp )
+ {
+ txtProp->GetColor( color );
+ font = txtProp->GetFontFamily();
+ bold = txtProp->GetBold();
+ italic = txtProp->GetItalic();
+ shadow = txtProp->GetShadow();
+ }
+ writer.writeStartElement("GraduatedAxis");
+ writer.writeAttribute("Axis", theAxis);
+
+ writer.writeStartElement("Title");
+ writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
+ writer.writeAttribute("Text", title);
+ writer.writeAttribute("Font", QString("%1").arg(font));
+ writer.writeAttribute("Bold", QString("%1").arg(bold));
+ writer.writeAttribute("Italic", QString("%1").arg(italic));
+ writer.writeAttribute("Shadow", QString("%1").arg(shadow));
+
+ writer.writeStartElement("Color");
+ writer.writeAttribute("R", QString("%1").arg(color[0]));
+ writer.writeAttribute("G", QString("%1").arg(color[1]));
+ writer.writeAttribute("B", QString("%1").arg(color[2]));
+ writer.writeEndElement();
+ writer.writeEndElement();
+
+ //params.sprintf( "* Graduated Axis: * Name *%u*%s*%.2f*%.2f*%.2f*%u*%u*%u*%u", isVisible,
+ // title.toLatin1().data(), color[0], color[1], color[2], font, bold, italic, shadow );
+
+ // Labels
+ isVisible = actor->GetLabelVisibility();
+ int labels = actor->GetNumberOfLabels();
+ int offset = actor->GetTickOffset();
+ font = PV3D_ARIAL;
+ bold = false;
+ italic = false;
+ shadow = false;
+
+ txtProp = actor->GetLabelTextProperty();
+ if ( txtProp )
+ {
+ txtProp->GetColor( color );
+ font = txtProp->GetFontFamily();
+ bold = txtProp->GetBold();
+ italic = txtProp->GetItalic();
+ shadow = txtProp->GetShadow();
+ }
+
+ writer.writeStartElement("Labels");
+ writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
+ writer.writeAttribute("Number", QString("%1").arg(labels));
+ writer.writeAttribute("Offset", QString("%1").arg(offset));
+ writer.writeAttribute("Font", QString("%1").arg(font));
+ writer.writeAttribute("Bold", QString("%1").arg(bold));
+ writer.writeAttribute("Italic", QString("%1").arg(italic));
+ writer.writeAttribute("Shadow", QString("%1").arg(shadow));
+
+ writer.writeStartElement("Color");
+ writer.writeAttribute("R", QString("%1").arg(color[0]));
+ writer.writeAttribute("G", QString("%1").arg(color[1]));
+ writer.writeAttribute("B", QString("%1").arg(color[2]));
+ writer.writeEndElement();
+ writer.writeEndElement();
+ // params += QString().sprintf( "* Labels *%u*%u*%u*%.2f*%.2f*%.2f*%u*%u*%u*%u", isVisible, labels, offset,
+ // color[0], color[1], color[2], font, bold, italic, shadow );
+
+ // Tick marks
+ isVisible = actor->GetTickVisibility();
+ int length = actor->GetTickLength();
+ writer.writeStartElement("TickMarks");
+ writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
+ writer.writeAttribute("Length", QString("%1").arg(length));
+ writer.writeEndElement();
+
+ //params += QString().sprintf( "* Tick marks *%u*%u", isVisible, length );
+
+ writer.writeEndElement();
+ //return params;
+}
+
+void setGradAxisVisualParams(QXmlStreamReader& reader, vtkAxisActor2D* actor)
+{
+ DBG_FUNC();
+ if ( !actor )
+ return;
+
+ do {
+ reader.readNext();
+ } while (!reader.isStartElement());
+
+ // Read title params
+ QXmlStreamAttributes aAttr = reader.attributes();
+ bool isVisible = aAttr.value("isVisible").toString().toUShort();
+ QString title = aAttr.value("Text").toString();
+ int font = aAttr.value("Font").toString().toInt();
+ int bold = aAttr.value("Bold").toString().toInt();
+ int italic = aAttr.value("Italic").toString().toInt();
+ int shadow = aAttr.value("Shadow").toString().toInt();
+
+ //printf("#### TITLE: %i, %s, %i, %i, %i, %i\n", isVisible, qPrintable(title), font, bold, italic, shadow);
+
+ do {
+ reader.readNext();
+ } while (!reader.isStartElement());
+
+ // Read title color
+ aAttr = reader.attributes();
+
+ double color[3];
+ color[0] = aAttr.value("R").toString().toDouble();
+ color[1] = aAttr.value("G").toString().toDouble();
+ color[2] = aAttr.value("B").toString().toDouble();
+ //printf("#### Color: %f, %f, %f\n", color[0], color[1], color[2]);
+
+ actor->SetTitleVisibility( isVisible );
+ actor->SetTitle( title.toUtf8() );
+ vtkTextProperty* txtProp = actor->GetTitleTextProperty();
+ if ( txtProp ) {
+ txtProp->SetColor( color );
+ txtProp->SetFontFamily( font );
+ txtProp->SetBold( bold );
+ txtProp->SetItalic( italic );
+ txtProp->SetShadow( shadow );
+ }
+
+ // Labels
+
+ do {
+ reader.readNext();
+ } while (!reader.isStartElement());
+ // Read labels
+ aAttr = reader.attributes();
+ isVisible = aAttr.value("isVisible").toString().toUShort();
+ int labels = aAttr.value("Number").toString().toInt();
+ int offset = aAttr.value("Offset").toString().toInt();
+ font = aAttr.value("Font").toString().toInt();
+ bold = aAttr.value("Bold").toString().toInt();
+ italic = aAttr.value("Italic").toString().toInt();
+ shadow = aAttr.value("Shadow").toString().toInt();
+
+ do {
+ reader.readNext();
+ } while (!reader.isStartElement());
+ // Read Color
+ aAttr = reader.attributes();
+
+ color[0] = aAttr.value("R").toString().toDouble();
+ color[1] = aAttr.value("G").toString().toDouble();
+ color[2] = aAttr.value("B").toString().toDouble();
+
+ actor->SetLabelVisibility( isVisible );
+ actor->SetNumberOfLabels( labels );
+ actor->SetTickOffset( offset );
+ txtProp = actor->GetLabelTextProperty();
+ if ( txtProp ) {
+ txtProp->SetColor( color );
+ txtProp->SetFontFamily( font );
+ txtProp->SetBold( bold );
+ txtProp->SetItalic( italic );
+ txtProp->SetShadow( shadow );
+ }
+
+ // Tick Marks
+ do {
+ reader.readNext();
+ } while (!reader.isStartElement());
+ aAttr = reader.attributes();
+
+ // retrieve and set tick marks properties
+ isVisible = aAttr.value("isVisible").toString().toUShort();
+ int length = aAttr.value("Length").toString().toInt();
+
+ actor->SetTickVisibility( isVisible );
+ actor->SetTickLength( length );
+}
+
+/*! The method restores visual parameters of a graduated axis actor (x,y,z axis)
+ */
+void setGradAxisVisualParams( vtkAxisActor2D* actor, const QString& params )
+{
+ DBG_FUNC();
+ if ( !actor )
+ return;
+
+ QStringList paramsLst = params.split( '*' );
+
+ if ( paramsLst.size() == nGradAxisParams ) { // altogether name, lable, ticks parameters make up 25 values
+
+ // retrieve and set name parameters
+ bool isVisible = paramsLst[2].toUShort();
+ QString title = paramsLst[3];
+ double color[3];
+ color[0] = paramsLst[4].toDouble();
+ color[1] = paramsLst[5].toDouble();
+ color[2] = paramsLst[6].toDouble();
+ int font = paramsLst[7].toInt();
+ int bold = paramsLst[8].toInt();
+ int italic = paramsLst[9].toInt();
+ int shadow = paramsLst[10].toInt();
+
+ actor->SetTitleVisibility( isVisible );
+ actor->SetTitle( title.toUtf8() );
+ vtkTextProperty* txtProp = actor->GetTitleTextProperty();
+ if ( txtProp ) {
+ txtProp->SetColor( color );
+ txtProp->SetFontFamily( font );
+ txtProp->SetBold( bold );
+ txtProp->SetItalic( italic );
+ txtProp->SetShadow( shadow );
+ }
+
+ // retrieve and set lable parameters
+ isVisible = paramsLst[12].toUShort();
+ int labels = paramsLst[13].toInt();
+ int offset = paramsLst[14].toInt();
+ color[0] = paramsLst[15].toDouble();
+ color[1] = paramsLst[16].toDouble();
+ color[2] = paramsLst[17].toDouble();
+ font = paramsLst[18].toInt();
+ bold = paramsLst[19].toInt();
+ italic = paramsLst[20].toInt();
+ shadow = paramsLst[21].toInt();
+
+ actor->SetLabelVisibility( isVisible );
+ actor->SetNumberOfLabels( labels );
+ actor->SetTickOffset( offset );
+ txtProp = actor->GetLabelTextProperty();
+ if ( txtProp ) {
+ txtProp->SetColor( color );
+ txtProp->SetFontFamily( font );
+ txtProp->SetBold( bold );
+ txtProp->SetItalic( italic );
+ txtProp->SetShadow( shadow );
+ }
+
+ // retrieve and set tick marks properties
+ isVisible = paramsLst[23].toUShort();
+ int length = paramsLst[24].toInt();
+
+ actor->SetTickVisibility( isVisible );
+ actor->SetTickLength( length );
+ }
+}
+
+/*! The method returns the visual parameters of this view as a formated string
+ */
+QString SPV3D_ViewWindow::getVisualParameters()
+{
+ double pos[3], focalPnt[3], viewUp[3], parScale, scale[3];
+
+ // save position, focal point, viewUp, scale
+ vtkCamera* camera = getRenderer()->GetActiveCamera();
+ camera->GetPosition( pos );
+ camera->GetFocalPoint( focalPnt );
+ camera->GetViewUp( viewUp );
+ parScale = camera->GetParallelScale();
+ GetScale( scale );
+
+ // Parameters are given in the following format:view position (3 digits), focal point position (3 digits)
+ // view up values (3 digits), parallel scale (1 digit), scale (3 digits,
+ // Graduated axes parameters (X, Y, Z axes parameters)
+ QString retStr;
+ QXmlStreamWriter aWriter(&retStr);
+ aWriter.setAutoFormatting(true);
+
+ aWriter.writeStartDocument();
+ aWriter.writeStartElement("ViewState");
+
+ aWriter.writeStartElement("Position");
+ aWriter.writeAttribute("X", QString("%1").arg(pos[0]));
+ aWriter.writeAttribute("Y", QString("%1").arg(pos[1]));
+ aWriter.writeAttribute("Z", QString("%1").arg(pos[2]));
+ aWriter.writeEndElement();
+
+ aWriter.writeStartElement("FocalPoint");
+ aWriter.writeAttribute("X", QString::number(focalPnt[0]));
+ aWriter.writeAttribute("Y", QString::number(focalPnt[1]));
+ aWriter.writeAttribute("Z", QString::number(focalPnt[2]));
+ aWriter.writeEndElement();
+
+ aWriter.writeStartElement("ViewUp");
+ aWriter.writeAttribute("X", QString::number(viewUp[0]));
+ aWriter.writeAttribute("Y", QString::number(viewUp[1]));
+ aWriter.writeAttribute("Z", QString::number(viewUp[2]));
+ aWriter.writeEndElement();
+
+ aWriter.writeStartElement("ViewScale");
+ aWriter.writeAttribute("Parallel", QString::number(parScale));
+ aWriter.writeAttribute("X", QString::number(scale[0]));
+ aWriter.writeAttribute("Y", QString::number(scale[1]));
+ aWriter.writeAttribute("Z", QString::number(scale[2]));
+ aWriter.writeEndElement();
+
+ if ( SPV3D_CubeAxesActor2D* gradAxesActor = GetCubeAxes() ) {
+ aWriter.writeStartElement("DisplayCubeAxis");
+ aWriter.writeAttribute("Show", QString( "%1" ).arg( GetRenderer()->IsCubeAxesDisplayed()));
+ aWriter.writeEndElement();
+
+ getGradAxisVisualParams(aWriter, gradAxesActor->GetXAxisActor2D(), "X");
+ getGradAxisVisualParams(aWriter, gradAxesActor->GetYAxisActor2D(), "Y");
+ getGradAxisVisualParams(aWriter, gradAxesActor->GetZAxisActor2D(), "Z");
+ }
+
+ aWriter.writeStartElement("Trihedron");
+ aWriter.writeAttribute("isShown", QString( "%1" ).arg( isTrihedronDisplayed()));
+ aWriter.writeAttribute("Size", QString::number(GetTrihedronSize()));
+ aWriter.writeEndElement();
+
+ aWriter.writeStartElement("Background");
+ aWriter.writeAttribute("Value", QString( "%1" ).arg( Qtx::backgroundToString(background()) ));
+ aWriter.writeEndElement();
+
+ aWriter.writeEndElement();
+ aWriter.writeEndDocument();
+
+ return retStr;
+}
+
+/*!
+ The method restores visual parameters of this view or postpones it untill the view is shown
+*/
+void SPV3D_ViewWindow::setVisualParameters( const QString& parameters )
+{
+ DBG_FUN();
+ //printf("#### %s\n", qPrintable(parameters));
+ SPV3D_RenderWindowInteractor* anInteractor = GetInteractor();
+ if ( anInteractor->isVisible() ) {
+ doSetVisualParameters( parameters );
+ }
+ else {
+ myVisualParams = parameters;
+ anInteractor->installEventFilter(this);
+ }
+}
+
+/*!
+ The method restores visual parameters of this view from a formated string
+*/
+void SPV3D_ViewWindow::doSetVisualParameters( const QString& parameters, bool baseParamsOnly )
+{
+ DBG_FUN();
+
+ double pos[3], focalPnt[3], viewUp[3], parScale = 1.0, scale[3];
+
+ QXmlStreamReader aReader(parameters);
+ SPV3D_CubeAxesActor2D* gradAxesActor = GetCubeAxes();
+
+ while(!aReader.atEnd()) {
+ aReader.readNext();
+ if (aReader.isStartElement()) {
+ QXmlStreamAttributes aAttr = aReader.attributes();
+ //printf("### Name = %s\n", qPrintable(aReader.name().toString()));
+ if (aReader.name() == "Position") {
+ pos[0] = aAttr.value("X").toString().toDouble();
+ pos[1] = aAttr.value("Y").toString().toDouble();
+ pos[2] = aAttr.value("Z").toString().toDouble();
+ //printf("#### Position %f; %f; %f\n", pos[0], pos[1], pos[2]);
+ }
+ else if (aReader.name() == "FocalPoint") {
+ focalPnt[0] = aAttr.value("X").toString().toDouble();
+ focalPnt[1] = aAttr.value("Y").toString().toDouble();
+ focalPnt[2] = aAttr.value("Z").toString().toDouble();
+ //printf("#### FocalPoint %f; %f; %f\n", focalPnt[0], focalPnt[1], focalPnt[2]);
+ }
+ else if (aReader.name() == "ViewUp") {
+ viewUp[0] = aAttr.value("X").toString().toDouble();
+ viewUp[1] = aAttr.value("Y").toString().toDouble();
+ viewUp[2] = aAttr.value("Z").toString().toDouble();
+ //printf("#### ViewUp %f; %f; %f\n", viewUp[0], viewUp[1], viewUp[2]);
+ }
+ else if (aReader.name() == "ViewScale") {
+ parScale = aAttr.value("Parallel").toString().toDouble();
+ scale[0] = aAttr.value("X").toString().toDouble();
+ scale[1] = aAttr.value("Y").toString().toDouble();
+ scale[2] = aAttr.value("Z").toString().toDouble();
+ //printf("#### ViewScale %f; %f; %f\n", scale[0], scale[1], scale[2]);
+ }
+ else if (aReader.name() == "DisplayCubeAxis") {
+ if ( !baseParamsOnly ) {
+ if (aAttr.value("Show") == "0")
+ gradAxesActor->VisibilityOff();
+ else
+ gradAxesActor->VisibilityOn();
+ }
+ }
+ else if (aReader.name() == "GraduatedAxis") {
+ if ( !baseParamsOnly ) {
+ if(aAttr.value("Axis") == "X")
+ setGradAxisVisualParams(aReader, gradAxesActor->GetXAxisActor2D());
+ else if(aAttr.value("Axis") == "Y")
+ setGradAxisVisualParams(aReader, gradAxesActor->GetYAxisActor2D());
+ else if(aAttr.value("Axis") == "Z")
+ setGradAxisVisualParams(aReader, gradAxesActor->GetZAxisActor2D());
+ }
+ }
+ else if (aReader.name() == "Trihedron") {
+ if ( !baseParamsOnly ) {
+ if (aAttr.value("isShown") == "0")
+ GetTrihedron()->VisibilityOff();
+ else
+ GetTrihedron()->VisibilityOn();
+ SetTrihedronSize(aAttr.value("Size").toString().toDouble());
+ }
+ }
+ else if (aReader.name() == "Background") {
+ if ( !baseParamsOnly ) {
+ setBackground( Qtx::stringToBackground( aAttr.value("Value").toString() ) );
+ }
+ }
+ }
+ }
+ if (!aReader.hasError()) {
+ vtkCamera* camera = getRenderer()->GetActiveCamera();
+ camera->SetPosition( pos );
+ camera->SetFocalPoint( focalPnt );
+ camera->SetViewUp( viewUp );
+ camera->SetParallelScale( parScale );
+ GetRenderer()->SetScale( scale );
+ //SetScale( scale );
+ }
+ else {
+ QStringList paramsLst = parameters.split( '*' );
+ if ( paramsLst.size() >= nNormalParams ) {
+ // 'reading' list of parameters
+ pos[0] = paramsLst[0].toDouble();
+ pos[1] = paramsLst[1].toDouble();
+ pos[2] = paramsLst[2].toDouble();
+ focalPnt[0] = paramsLst[3].toDouble();
+ focalPnt[1] = paramsLst[4].toDouble();
+ focalPnt[2] = paramsLst[5].toDouble();
+ viewUp[0] = paramsLst[6].toDouble();
+ viewUp[1] = paramsLst[7].toDouble();
+ viewUp[2] = paramsLst[8].toDouble();
+ parScale = paramsLst[9].toDouble();
+ scale[0] = paramsLst[10].toDouble();
+ scale[1] = paramsLst[11].toDouble();
+ scale[2] = paramsLst[12].toDouble();
+
+ // applying parameters
+ vtkCamera* camera = getRenderer()->GetActiveCamera();
+ camera->SetPosition( pos );
+ camera->SetFocalPoint( focalPnt );
+ camera->SetViewUp( viewUp );
+ camera->SetParallelScale( parScale );
+ GetRenderer()->SetScale( scale );
+ //SetScale( scale );
+
+ // apply graduated axes parameters
+ if ( !baseParamsOnly ) {
+ SPV3D_CubeAxesActor2D* gradAxesActor = GetCubeAxes();
+ if ( gradAxesActor && paramsLst.size() == nAllParams ) {
+ int i = nNormalParams+1, j = i + nGradAxisParams - 1;
+ ::setGradAxisVisualParams( gradAxesActor->GetXAxisActor2D(), parameters.section( '*', i, j ) );
+ i = j + 1; j += nGradAxisParams;
+ ::setGradAxisVisualParams( gradAxesActor->GetYAxisActor2D(), parameters.section( '*', i, j ) );
+ i = j + 1; j += nGradAxisParams;
+ ::setGradAxisVisualParams( gradAxesActor->GetZAxisActor2D(), parameters.section( '*', i, j ) );
+
+ if ( paramsLst[13].toUShort() )
+ gradAxesActor->VisibilityOn();
+ else
+ gradAxesActor->VisibilityOff();
+ }
+ else if ( paramsLst.size() == nAllParams ) {
+ if ( paramsLst[90].toUShort() )
+ GetTrihedron()->VisibilityOn();
+ else
+ GetTrihedron()->VisibilityOff();
+
+ SetTrihedronSize(paramsLst[91].toDouble());
+ }
+ }
+ }
+ }
+ Repaint();
+}
+
+
+/*!
+ Delayed setVisualParameters
+*/
+bool SPV3D_ViewWindow::eventFilter( QObject* theWatched, QEvent* theEvent )
+{
+ if ( theEvent->type() == QEvent::Show && theWatched->inherits( "SPV3D_RenderWindowInteractor" ) ) {
+ SPV3D_RenderWindowInteractor* anInteractor = (SPV3D_RenderWindowInteractor*)theWatched;
+ if ( anInteractor->isVisible() ) {
+ doSetVisualParameters( myVisualParams );
+ anInteractor->removeEventFilter( this ); // theWatched = RenderWindowInteractor
+ }
+ }
+ return SUIT_ViewWindow::eventFilter( theWatched, theEvent );
+}
+
+
+/*!
+ Change rotation point
+*/
+void SPV3D_ViewWindow::onChangeRotationPoint(bool theIsActivate)
+{
+ if(theIsActivate){
+ mySetRotationPointDlg->addObserver();
+ if ( mySetRotationPointDlg->IsFirstShown() )
+ activateSetRotationGravity();
+ mySetRotationPointDlg->show();
+ }else
+ mySetRotationPointDlg->hide();
+}
+
+/*!
+ Set the gravity center as a rotation point
+*/
+void SPV3D_ViewWindow::activateSetRotationGravity()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::SetRotateGravity,0);
+}
+
+/*!
+ Set the selected point as a rotation point
+*/
+void SPV3D_ViewWindow::activateSetRotationSelected(void* theData)
+{
+ myEventDispatcher->InvokeEvent(SPV3D::ChangeRotationPoint,theData);
+}
+
+/*!
+ Set the gravity center of element selected by user as a rotation point
+*/
+void SPV3D_ViewWindow::activateStartPointSelection( Selection_Mode theSelectionMode )
+{
+ SetSelectionMode( theSelectionMode );
+ myEventDispatcher->InvokeEvent(SPV3D::StartPointSelection,0);
+}
+
+/*!
+ \brief Set the given projection mode.
+
+ Set the given projection mode: Orthographic or Perspective.
+*/
+void SPV3D_ViewWindow::onProjectionMode( QAction* theAction )
+{
+ DBG_FUN();
+ int aMode = Parallel;
+ if (theAction == toolMgr()->action( ProjectionModeId ))
+ aMode = Projection;
+ SPV3D_Viewer* aViewer = dynamic_cast<SPV3D_Viewer*>(myModel);
+ aViewer->setProjectionMode(aMode);
+ bool anIsParallelMode = (aMode == Parallel);
+ vtkCamera* aCamera = getRenderer()->GetActiveCamera();
+ aCamera->SetParallelProjection(anIsParallelMode);
+ GetInteractor()->GetDevice()->CreateTimer(PV3DI_TIMER_FIRST);
+ getRenderWindow()->SetStereoRender(0);
+ Repaint();
+}
+
+/*!
+ \brief Sets Stereo projection mode.
+
+ Sets Stereo projection mode.
+*/
+void SPV3D_ViewWindow::onStereoMode( bool activate )
+{
+ DBG_FUN();
+ if (activate) {
+ toolMgr()->action( ProjectionModeId )->setChecked(true);
+ vtkCamera* aCamera = getRenderer()->GetActiveCamera();
+ aCamera->SetParallelProjection(false);
+ toolMgr()->action( ProjectionModeId )->actionGroup()->setEnabled(false);
+ SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
+ SetStereoType( aResMgr->integerValue( "PV3DViewer", "stereo_type", 0 ) );
+ getRenderWindow()->SetStereoRender(1);
+ Repaint();
+ }
+ else {
+ toolMgr()->action( ProjectionModeId )->actionGroup()->setEnabled(true);
+ SPV3D_Viewer* aViewer = dynamic_cast<SPV3D_Viewer*>(myModel);
+ if (aViewer->projectionMode() == Parallel) {
+ toolMgr()->action( ParallelModeId )->setChecked(true);
+ onProjectionMode(toolMgr()->action( ParallelModeId ));
+ }
+ else if (aViewer->projectionMode() == Projection) {
+ toolMgr()->action( ProjectionModeId )->setChecked(true);
+ onProjectionMode(toolMgr()->action( ProjectionModeId ));
+ }
+ }
+ if ( getRenderWindow()->GetStereoCapableWindow() == 1 && !isOpenGlStereoSupport() &&
+ strcmp( "CrystalEyes", getRenderWindow()->GetStereoTypeAsString() ) == 0 &&
+ toolMgr()->action( StereoModeId )->isChecked() )
+ SUIT_MessageBox::warning( 0, tr( "WRN_WARNING" ), tr( "WRN_SUPPORT_QUAD_BUFFER" ) );
+}
+
+/*!
+ Set the view projection mode: orthogonal or perspective
+*/
+void SPV3D_ViewWindow::onProjectionMode()
+{
+ DBG_FUN();
+ if (toolMgr()->action( ParallelModeId )->isChecked())
+ SetProjectionMode( Parallel);
+ if (toolMgr()->action( ProjectionModeId )->isChecked())
+ SetProjectionMode( Projection);
+ if (toolMgr()->action( StereoModeId )->isChecked())
+ SetProjectionMode( Stereo);
+ emit transformed( this );
+}
+
+void SPV3D_ViewWindow::SetEventDispatcher(vtkObject* theDispatcher)
+{
+ myEventDispatcher = theDispatcher;
+}
+
+/*!
+ Creates all actions of svtk main window
+*/
+void SPV3D_ViewWindow::createActions(SUIT_ResourceMgr* theResourceMgr)
+{
+ DBG_FUN();
+ QtxAction* anAction;
+ QtxActionToolMgr* mgr = toolMgr();
+
+ // Dump view
+ anAction = new QtxAction(tr("MNU_DUMP_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_DUMP" ) ),
+ tr( "MNU_DUMP_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_DUMP_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onDumpView()));
+ mgr->registerAction( anAction, DumpId );
+
+ // FitAll
+ anAction = new QtxAction(tr("MNU_FITALL"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_FITALL" ) ),
+ tr( "MNU_FITALL" ), 0, this);
+ anAction->setStatusTip(tr("DSC_FITALL"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onFitAll()));
+ mgr->registerAction( anAction, FitAllId );
+
+ // FitRect
+ anAction = new QtxAction(tr("MNU_FITRECT"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_FITAREA" ) ),
+ tr( "MNU_FITRECT" ), 0, this);
+ anAction->setStatusTip(tr("DSC_FITRECT"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(activateWindowFit()));
+ mgr->registerAction( anAction, FitRectId );
+
+ // FitSelection
+ anAction = new QtxAction(tr("MNU_FITSELECTION"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_FITSELECTION" ) ),
+ tr( "MNU_FITSELECTION" ), 0, this);
+ anAction->setStatusTip(tr("DSC_FITSELECTION"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onFitSelection()));
+ mgr->registerAction( anAction, FitSelectionId );
+
+ // Zoom
+ anAction = new QtxAction(tr("MNU_ZOOM_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_ZOOM" ) ),
+ tr( "MNU_ZOOM_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_ZOOM_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(activateZoom()));
+ mgr->registerAction( anAction, ZoomId );
+
+ // Panning
+ anAction = new QtxAction(tr("MNU_PAN_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_PAN" ) ),
+ tr( "MNU_PAN_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_PAN_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(activatePanning()));
+ mgr->registerAction( anAction, PanId );
+
+ // Global Panning
+ anAction = new QtxAction(tr("MNU_GLOBALPAN_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_GLOBALPAN" ) ),
+ tr( "MNU_GLOBALPAN_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_GLOBALPAN_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(activateGlobalPanning()));
+ mgr->registerAction( anAction, GlobalPanId );
+
+ // Change rotation point
+ anAction = new QtxAction(tr("MNU_CHANGINGROTATIONPOINT_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_ROTATION_POINT" ) ),
+ tr( "MNU_CHANGINGROTATIONPOINT_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_CHANGINGROTATIONPOINT_VIEW"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onChangeRotationPoint(bool)));
+ mgr->registerAction( anAction, ChangeRotationPointId );
+
+ // Rotation
+ anAction = new QtxAction(tr("MNU_ROTATE_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_ROTATE" ) ),
+ tr( "MNU_ROTATE_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_ROTATE_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(activateRotation()));
+ mgr->registerAction( anAction, RotationId );
+
+ // Projections
+ anAction = new QtxAction(tr("MNU_FRONT_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_FRONT" ) ),
+ tr( "MNU_FRONT_VIEW" ), 0, this, false, "Viewers:Front view");
+ anAction->setStatusTip(tr("DSC_FRONT_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onFrontView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, FrontId );
+
+ anAction = new QtxAction(tr("MNU_BACK_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_BACK" ) ),
+ tr( "MNU_BACK_VIEW" ), 0, this, false, "Viewers:Back view");
+ anAction->setStatusTip(tr("DSC_BACK_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onBackView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, BackId );
+
+ anAction = new QtxAction(tr("MNU_TOP_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_TOP" ) ),
+ tr( "MNU_TOP_VIEW" ), 0, this, false, "Viewers:Top view");
+ anAction->setStatusTip(tr("DSC_TOP_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onTopView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, TopId );
+
+ anAction = new QtxAction(tr("MNU_BOTTOM_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_BOTTOM" ) ),
+ tr( "MNU_BOTTOM_VIEW" ), 0, this, false, "Viewers:Bottom view");
+ anAction->setStatusTip(tr("DSC_BOTTOM_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onBottomView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, BottomId );
+
+ anAction = new QtxAction(tr("MNU_LEFT_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_LEFT" ) ),
+ tr( "MNU_LEFT_VIEW" ), 0, this, false, "Viewers:Left view");
+ anAction->setStatusTip(tr("DSC_LEFT_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onLeftView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, LeftId );
+
+ anAction = new QtxAction(tr("MNU_RIGHT_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_RIGHT" ) ),
+ tr( "MNU_RIGHT_VIEW" ), 0, this, false, "Viewers:Right view");
+ anAction->setStatusTip(tr("DSC_RIGHT_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onRightView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, RightId );
+
+ // rotate anticlockwise
+ anAction = new QtxAction(tr("MNU_ANTICLOCKWISE_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_ANTICLOCKWISE" ) ),
+ tr( "MNU_ANTICLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate anticlockwise");
+ anAction->setStatusTip(tr("DSC_ANTICLOCKWISE_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onAntiClockWiseView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, AntiClockWiseId );
+
+ // rotate clockwise
+ anAction = new QtxAction(tr("MNU_CLOCKWISE_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_CLOCKWISE" ) ),
+ tr( "MNU_CLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate clockwise");
+ anAction->setStatusTip(tr("DSC_CLOCKWISE_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onClockWiseView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, ClockWiseId );
+
+ // Reset
+ anAction = new QtxAction(tr("MNU_RESET_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_RESET" ) ),
+ tr( "MNU_RESET_VIEW" ), 0, this, false, "Viewers:Reset view");
+ anAction->setStatusTip(tr("DSC_RESET_VIEW"));
+ connect(anAction, SIGNAL(triggered()), this, SLOT(onResetView()));
+ this->addAction(anAction);
+ mgr->registerAction( anAction, ResetId );
+
+ // onViewTrihedron: Shows - Hides Trihedron
+ anAction = new QtxAction(tr("MNU_SHOW_TRIHEDRON"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_PV3DVIEWER_VIEW_TRIHEDRON" ) ),
+ tr( "MNU_SHOW_TRIHEDRON" ), 0, this);
+ anAction->setCheckable( true );
+ anAction->setChecked( true );
+
+ anAction->setStatusTip(tr("DSC_SHOW_TRIHEDRON"));
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onViewTrihedron(bool)));
+ mgr->registerAction( anAction, ViewTrihedronId );
+
+ // onNonIsometric: Manage non-isometric params
+ anAction = new QtxAction(tr("MNU_SPV3D_SCALING"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_SCALING" ) ),
+ tr( "MNU_SPV3D_SCALING" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_SCALING"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onNonIsometric(bool)));
+ mgr->registerAction( anAction, NonIsometric );
+
+ // onGraduatedAxes: Manage graduated axes params
+ anAction = new QtxAction(tr("MNU_SPV3D_GRADUATED_AXES"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_GRADUATED_AXES" ) ),
+ tr( "MNU_SPV3D_GRADUATED_AXES" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_GRADUATED_AXES"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onGraduatedAxes(bool)));
+ mgr->registerAction( anAction, GraduatedAxes );
+
+ // onGraduatedAxes: Manage graduated axes params
+ anAction = new QtxAction(tr("MNU_SPV3D_UPDATE_RATE"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_UPDATE_RATE" ) ),
+ tr( "MNU_SPV3D_UPDATE_RATE" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_UPDATE_RATE"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onUpdateRate(bool)));
+ mgr->registerAction( anAction, UpdateRate );
+
+ // Set perspective mode group
+ anAction = new QtxAction(tr("MNU_SPV3D_PARALLEL_MODE"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_VIEW_PARALLEL" ) ),
+ tr( "MNU_SPV3D_PARALLEL_MODE" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_PARALLEL_MODE"));
+ anAction->setCheckable(true);
+ mgr->registerAction( anAction, ParallelModeId );
+
+ anAction = new QtxAction(tr("MNU_SPV3D_PERSPECTIVE_MODE"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_VIEW_PERSPECTIVE" ) ),
+ tr( "MNU_SPV3D_PERSPECTIVE_MODE" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_PERSPECTIVE_MODE"));
+ anAction->setCheckable(true);
+ mgr->registerAction( anAction, ProjectionModeId );
+
+ anAction = new QtxAction(tr("MNU_SPV3D_STEREO_MODE"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_VIEW_STEREO" ) ),
+ tr( "MNU_SPV3D_STEREO_MODE" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_STEREO_MODE"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(triggered(bool)), this, SLOT(onStereoMode(bool)));
+ mgr->registerAction( anAction, StereoModeId );
+
+ QActionGroup* aPerspectiveGroup = new QActionGroup( this );
+ aPerspectiveGroup->addAction( mgr->action( ParallelModeId ) );
+ aPerspectiveGroup->addAction( mgr->action( ProjectionModeId ) );
+ connect(aPerspectiveGroup, SIGNAL(triggered(QAction*)), this, SLOT(onProjectionMode(QAction*)));
+
+ // View Parameters
+ anAction = new QtxAction(tr("MNU_VIEWPARAMETERS_VIEW"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_VIEW_PARAMETERS" ) ),
+ tr( "MNU_VIEWPARAMETERS_VIEW" ), 0, this);
+ anAction->setStatusTip(tr("DSC_VIEWPARAMETERS_VIEW"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onViewParameters(bool)));
+ mgr->registerAction( anAction, ViewParametersId );
+
+ // Synchronize View
+ mgr->registerAction( synchronizeAction(), SynchronizeId );
+
+ // Switch between interaction styles
+ anAction = new QtxAction(tr("MNU_SPV3D_STYLE_SWITCH"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_STYLE_SWITCH" ) ),
+ tr( "MNU_SPV3D_STYLE_SWITCH" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_STYLE_SWITCH"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchInteractionStyle(bool)));
+ mgr->registerAction( anAction, SwitchInteractionStyleId );
+
+ // Switch between zooming styles
+ anAction = new QtxAction(tr("MNU_SPV3D_ZOOMING_STYLE_SWITCH"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_ZOOMING_STYLE_SWITCH" ) ),
+ tr( "MNU_SPV3D_ZOOMING_STYLE_SWITCH" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_ZOOMING_STYLE_SWITCH"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchZoomingStyle(bool)));
+ mgr->registerAction( anAction, SwitchZoomingStyleId );
+
+ // Pre-selection
+ QSignalMapper* aSignalMapper = new QSignalMapper( this );
+ connect(aSignalMapper, SIGNAL(mapped(int)), this, SLOT(onSwitchPreSelectionMode(int)));
+
+ anAction = new QtxAction(tr("MNU_SPV3D_PRESELECTION_STANDARD"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_PRESELECTION_STANDARD" ) ),
+ tr( "MNU_SPV3D_PRESELECTION_STANDARD" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_PRESELECTION_STANDARD"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(triggered()), aSignalMapper, SLOT(map()));
+ aSignalMapper->setMapping( anAction, Standard_Preselection );
+ mgr->registerAction( anAction, StandardPreselectionId );
+
+ anAction = new QtxAction(tr("MNU_SPV3D_PRESELECTION_DYNAMIC"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_PRESELECTION_DYNAMIC" ) ),
+ tr( "MNU_SPV3D_PRESELECTION_DYNAMIC" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_PRESELECTION_DYNAMIC"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(triggered()), aSignalMapper, SLOT(map()));
+ aSignalMapper->setMapping( anAction, Dynamic_Preselection );
+ mgr->registerAction( anAction, DynamicPreselectionId );
+
+ anAction = new QtxAction(tr("MNU_SPV3D_PRESELECTION_DISABLED"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_PRESELECTION_DISABLED" ) ),
+ tr( "MNU_SPV3D_PRESELECTION_DISABLED" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_PRESELECTION_DISABLED"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(triggered()), aSignalMapper, SLOT(map()));
+ aSignalMapper->setMapping( anAction, Preselection_Disabled );
+ mgr->registerAction( anAction, DisablePreselectionId );
+
+ QtxActionGroup* aPreselectionAction = new QtxActionGroup( this, true );
+ aPreselectionAction->add( getAction( StandardPreselectionId ) );
+ aPreselectionAction->add( getAction( DynamicPreselectionId ) );
+ aPreselectionAction->add( getAction( DisablePreselectionId ) );
+ mgr->registerAction( aPreselectionAction, PreselectionId );
+
+ // Selection
+ anAction = new QtxAction(tr("MNU_SPV3D_ENABLE_SELECTION"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_SELECTION" ) ),
+ tr( "MNU_SPV3D_ENABLE_SELECTION" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SPV3D_ENABLE_SELECTION"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onEnableSelection(bool)));
+ mgr->registerAction( anAction, EnableSelectionId );
+
+ // Start recording
+ myStartAction = new QtxAction(tr("MNU_SPV3D_RECORDING_START"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_RECORDING_START" ) ),
+ tr( "MNU_SPV3D_RECORDING_START" ), 0, this);
+ myStartAction->setStatusTip(tr("DSC_SPV3D_RECORDING_START"));
+ connect( myStartAction, SIGNAL( triggered ( bool ) ), this, SLOT( onStartRecording() ) );
+ mgr->registerAction( myStartAction, StartRecordingId );
+
+ // Play recording
+ myPlayAction = new QtxAction(tr("MNU_SPV3D_RECORDING_PLAY"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_RECORDING_PLAY" ) ),
+ tr( "MNU_SPV3D_RECORDING_PLAY" ), 0, this);
+ myPlayAction->setStatusTip(tr("DSC_SPV3D_RECORDING_PLAY"));
+ myPlayAction->setEnabled( false );
+ connect( myPlayAction, SIGNAL( triggered ( bool ) ), this, SLOT( onPlayRecording() ) );
+ mgr->registerAction( myPlayAction, PlayRecordingId );
+
+ // Pause recording
+ myPauseAction = new QtxAction(tr("MNU_SPV3D_RECORDING_PAUSE"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_RECORDING_PAUSE" ) ),
+ tr( "MNU_SPV3D_RECORDING_PAUSE" ), 0, this);
+ myPauseAction->setStatusTip(tr("DSC_SPV3D_RECORDING_PAUSE"));
+ myPauseAction->setEnabled( false );
+ connect( myPauseAction, SIGNAL( triggered ( bool ) ), this, SLOT( onPauseRecording() ) );
+ mgr->registerAction( myPauseAction, PauseRecordingId );
+
+ // Stop recording
+ myStopAction = new QtxAction(tr("MNU_SPV3D_RECORDING_STOP"),
+ theResourceMgr->loadPixmap( "PV3DViewer", tr( "ICON_SPV3D_RECORDING_STOP" ) ),
+ tr( "MNU_SPV3D_RECORDING_STOP" ), 0, this);
+ myStopAction->setStatusTip(tr("DSC_SPV3D_RECORDING_STOP"));
+ myStopAction->setEnabled( false );
+ connect( myStopAction, SIGNAL( triggered ( bool ) ), this, SLOT( onStopRecording() ) );
+ mgr->registerAction( myStopAction, StopRecordingId );
+}
+
+/*!
+ Creates toolbar of svtk main window
+*/
+void SPV3D_ViewWindow::createToolBar()
+{
+ QtxActionToolMgr* mgr = toolMgr();
+
+ mgr->append( DumpId, myToolBar );
+ mgr->append( SwitchInteractionStyleId, myToolBar );
+ mgr->append( SwitchZoomingStyleId, myToolBar );
+
+ mgr->append( mgr->separator(), myToolBar );
+
+ mgr->append( PreselectionId, myToolBar );
+ mgr->append( EnableSelectionId, myToolBar );
+
+ mgr->append( mgr->separator(), myToolBar );
+
+ mgr->append( ViewTrihedronId, myToolBar );
+
+ QtxMultiAction* aScaleAction = new QtxMultiAction( this );
+ aScaleAction->insertAction( getAction( FitAllId ) );
+ aScaleAction->insertAction( getAction( FitRectId ) );
+ aScaleAction->insertAction( getAction( FitSelectionId ) );
+ aScaleAction->insertAction( getAction( ZoomId ) );
+ mgr->append( aScaleAction, myToolBar );
+
+ QtxMultiAction* aPanningAction = new QtxMultiAction( this );
+ aPanningAction->insertAction( getAction( PanId ) );
+ aPanningAction->insertAction( getAction( GlobalPanId ) );
+ mgr->append( aPanningAction, myToolBar );
+
+ mgr->append( ChangeRotationPointId, myToolBar );
+
+ mgr->append( RotationId, myToolBar );
+
+ QtxMultiAction* aViewsAction = new QtxMultiAction( this );
+ aViewsAction->insertAction( getAction( FrontId ) );
+ aViewsAction->insertAction( getAction( BackId ) );
+ aViewsAction->insertAction( getAction( TopId ) );
+ aViewsAction->insertAction( getAction( BottomId ) );
+ aViewsAction->insertAction( getAction( LeftId ) );
+ aViewsAction->insertAction( getAction( RightId ) );
+ mgr->append( aViewsAction, myToolBar );
+
+ mgr->append( AntiClockWiseId, myToolBar );
+ mgr->append( ClockWiseId, myToolBar );
+
+ mgr->append( ResetId, myToolBar );
+
+ mgr->append( UpdateRate, myToolBar );
+ mgr->append( NonIsometric, myToolBar );
+ mgr->append( GraduatedAxes, myToolBar );
+
+ mgr->append( ViewParametersId, myToolBar );
+ mgr->append( SynchronizeId, myToolBar );
+
+ mgr->append( toolMgr()->separator(), myToolBar );
+
+ mgr->append( ParallelModeId, myToolBar );
+ mgr->append( ProjectionModeId, myToolBar );
+ mgr->append( StereoModeId, myToolBar );
+
+ mgr->append( StartRecordingId, myRecordingToolBar );
+ mgr->append( PlayRecordingId, myRecordingToolBar );
+ mgr->append( PauseRecordingId, myRecordingToolBar );
+ mgr->append( StopRecordingId, myRecordingToolBar );
+}
+
+void SPV3D_ViewWindow::onUpdateRate(bool theIsActivate)
+{
+ if(theIsActivate){
+ myUpdateRateDlg->Update();
+ myUpdateRateDlg->show();
+ }else
+ myUpdateRateDlg->hide();
+}
+
+void SPV3D_ViewWindow::onNonIsometric(bool theIsActivate)
+{
+ if(theIsActivate){
+ myNonIsometricDlg->Update();
+ myNonIsometricDlg->show();
+ }else
+ myNonIsometricDlg->hide();
+}
+
+void SPV3D_ViewWindow::onGraduatedAxes(bool theIsActivate)
+{
+ if(theIsActivate){
+ myCubeAxesDlg->Update();
+ myCubeAxesDlg->show();
+ }else
+ myCubeAxesDlg->hide();
+}
+
+/*!
+ Starts rotation transformation
+*/
+void SPV3D_ViewWindow::activateRotation()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartRotate,0);
+}
+
+
+/*!
+ Starts panning transformation
+*/
+void SPV3D_ViewWindow::activatePanning()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartPan,0);
+}
+
+/*!
+ Starts zoom transformation
+*/
+void SPV3D_ViewWindow::activateZoom()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartZoom,0);
+}
+
+/*!
+ Starts window fit transformation
+*/
+void SPV3D_ViewWindow::activateWindowFit()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartFitArea,0);
+}
+
+/*!
+ Starts global panning transformation
+*/
+void SPV3D_ViewWindow::activateGlobalPanning()
+{
+ myEventDispatcher->InvokeEvent(SPV3D::StartGlobalPan,0);
+}
+
+void SPV3D_ViewWindow::onStartRecording()
+{
+ myRecorder->CheckExistAVIMaker();
+ if (myRecorder->ErrorStatus()) {
+ SUIT_MessageBox::warning(this, tr("ERROR"), tr("MSG_NO_AVI_MAKER") );
+ }
+ else {
+ SPV3D_RecorderDlg* aRecorderDlg = new SPV3D_RecorderDlg( this, myRecorder );
+
+ if( !aRecorderDlg->exec() )
+ return;
+
+ myStartAction->setEnabled( false );
+ myPlayAction->setEnabled( false );
+ myPauseAction->setEnabled( true );
+ myStopAction->setEnabled( true );
+
+ // to prevent resizing the window while recording
+ myPreRecordingMinSize = minimumSize();
+ myPreRecordingMaxSize = maximumSize();
+ setFixedSize( size() );
+
+ myRecorder->Record();
+ }
+}
+
+void SPV3D_ViewWindow::onPlayRecording()
+{
+ myStartAction->setEnabled( false );
+ myPlayAction->setEnabled( false );
+ myPauseAction->setEnabled( true );
+ myStopAction->setEnabled( true );
+
+ myRecorder->Pause();
+}
+
+void SPV3D_ViewWindow::onPauseRecording()
+{
+ myStartAction->setEnabled( false );
+ myPlayAction->setEnabled( true );
+ myPauseAction->setEnabled( false );
+ myStopAction->setEnabled( true );
+
+ myRecorder->Pause();
+}
+
+void SPV3D_ViewWindow::onStopRecording()
+{
+ myStartAction->setEnabled( true );
+ myPlayAction->setEnabled( false );
+ myPauseAction->setEnabled( false );
+ myStopAction->setEnabled( false );
+
+ myRecorder->Stop();
+
+ setMinimumSize( myPreRecordingMinSize );
+ setMaximumSize( myPreRecordingMaxSize );
+}
+
+/*!
+ To invoke a PV3D event on SPV3D_RenderWindowInteractor instance
+*/
+void SPV3D_ViewWindow::InvokeEvent(unsigned long theEvent, void* theCallData)
+{
+ GetInteractor()->InvokeEvent(theEvent,theCallData);
+}
+
+/*!
+ Modify view parameters
+*/
+void SPV3D_ViewWindow::onViewParameters(bool theIsActivate)
+{
+ if(theIsActivate){
+ myViewParameterDlg->addObserver();
+ myViewParameterDlg->show();
+ }else
+ myViewParameterDlg->hide();
+}
+#endif
+
+/*!
+ Custom show event handler
+*/
+void SPV3D_ViewWindow::showEvent( QShowEvent * theEvent )
+{
+ DBG_FUN();
+ MSGEL("-----> emit Show <-----");
+ emit Show( theEvent );
+}
+
+/*!
+ Custom hide event handler
+*/
+void SPV3D_ViewWindow::hideEvent( QHideEvent * theEvent )
+{
+ DBG_FUN();
+ MSGEL("-----> emit Hide <-----");
+ emit Hide( theEvent );
+}
+
+#if 0
+/*!
+ Emit transformed signal.
+*/
+void SPV3D_ViewWindow::emitTransformed() {
+ transformed(this);
+}
+
+/*!
+ Processes events
+*/
+void SPV3D_ViewWindow::ProcessEvents(vtkObject* vtkNotUsed(theObject),
+ unsigned long /*theEvent*/,
+ void* theClientData,
+ void* /*theCallData*/)
+{
+ SPV3D_ViewWindow* self = reinterpret_cast<SPV3D_ViewWindow*>(theClientData);
+ if(self)
+ self->emitTransformed();
+}
+
+/*!
+ Get camera properties for the SPV3D view window.
+ \return shared pointer on camera properties.
+*/
+SUIT_CameraProperties SPV3D_ViewWindow::cameraProperties()
+{
+ SUIT_CameraProperties aProps;
+
+ // get vtk camera
+ vtkCamera* aCamera = getRenderer()->GetActiveCamera();
+ if ( !aCamera )
+ return aProps;
+
+ aProps.setDimension( SUIT_CameraProperties::Dim3D );
+ if ( toolMgr()->action( ParallelModeId ) ) {
+ if ( toolMgr()->action( ParallelModeId )->isChecked() )
+ aProps.setProjection( SUIT_CameraProperties::PrjOrthogonal );
+ else
+ aProps.setProjection( SUIT_CameraProperties::PrjPerspective );
+ }
+
+ double aFocalPoint[3];
+ double aPosition[3];
+ double aViewUp[3];
+ double anAxialScale[3];
+
+ aCamera->OrthogonalizeViewUp();
+ aCamera->GetFocalPoint( aFocalPoint );
+ aCamera->GetPosition( aPosition );
+ aCamera->GetViewUp( aViewUp );
+
+ aProps.setFocalPoint( aFocalPoint[0], aFocalPoint[1], aFocalPoint[2] );
+ aProps.setPosition( aPosition[0], aPosition[1], aPosition[2] );
+ aProps.setViewUp( aViewUp[0], aViewUp[1], aViewUp[2] );
+ aProps.setMappingScale( aCamera->GetParallelScale() * 2.0 );
+
+ if ( aProps.getProjection() == SUIT_CameraProperties::PrjPerspective )
+ {
+ aProps.setViewAngle( aCamera->GetViewAngle() );
+ }
+
+ GetRenderer()->GetScale( anAxialScale );
+ aProps.setAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
+
+ return aProps;
+}
+
+/*!
+ Synchronize views.
+ This implementation synchronizes camera propreties.
+*/
+void SPV3D_ViewWindow::synchronize( SUIT_ViewWindow* theView )
+{
+ bool blocked = blockSignals( true );
+
+ SUIT_CameraProperties aProps = theView->cameraProperties();
+ if ( !cameraProperties().isCompatible( aProps ) ) {
+ // other view, this one is being currently synchronized to, seems has become incompatible
+ // we have to break synchronization
+ updateSyncViews();
+ return;
+ }
+
+ // get camera
+ vtkCamera* aCamera = getRenderer()->GetActiveCamera();
+
+ double aFocalPoint[3];
+ double aPosition[3];
+ double aViewUp[3];
+ double anAxialScale[3];
+
+ // get common properties
+ aProps.getViewUp( aViewUp[0], aViewUp[1], aViewUp[2] );
+ aProps.getPosition( aPosition[0], aPosition[1], aPosition[2] );
+ aProps.getFocalPoint( aFocalPoint[0], aFocalPoint[1], aFocalPoint[2] );
+ aProps.getAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
+
+ // restore properties to the camera
+ aCamera->SetViewUp( aViewUp );
+ aCamera->SetPosition( aPosition );
+ aCamera->SetFocalPoint( aFocalPoint );
+ aCamera->SetParallelScale( aProps.getMappingScale() / 2.0 );
+
+ if ( aProps.getProjection() == SUIT_CameraProperties::PrjPerspective )
+ {
+ aCamera->SetViewAngle( aProps.getViewAngle() );
+ }
+
+ GetRenderer()->SetScale( anAxialScale );
+
+ getRenderer()->ResetCameraClippingRange();
+ Repaint( false );
+
+ blockSignals( blocked );
+}
+
+void SPV3D_ViewWindow::resizeEvent( QResizeEvent* theEvent )
+{
+#ifdef VGL_WORKAROUND
+ Repaint();
+#endif
+}
+#endif
--- /dev/null
+// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef SPV3D_VIEWWINDOW_H
+#define SPV3D_VIEWWINDOW_H
+
+#ifdef WIN32
+#pragma warning( disable:4251 )
+#endif
+
+#include "SPV3D.h"
+//#include "SPV3D_Selection.h"
+#include "Qtx.h"
+//#include "SUIT_ViewWindow.h"
+#include "PV3DViewer_ViewWindow.h"
+
+#include "SALOME_InteractiveObject.hxx"
+#include "SALOME_ListIO.hxx"
+
+#include <QImage>
+#include <vtkSmartPointer.h>
+
+class SUIT_Desktop;
+class SUIT_ResourceMgr;
+
+class PV3DViewer_Actor;
+class PV3DViewer_Trihedron;
+
+class SPV3D_ViewModel/*Base*/;
+class SPV3D_Selector;
+class SPV3D_View;
+
+class SPV3D_CubeAxesActor2D;
+
+class vtkRenderer;
+class vtkRenderWindow;
+class vtkRenderWindowInteractor;
+class vtkInteractorStyle;
+class vtkCallbackCommand;
+
+class SPV3D_RenderWindowInteractor;
+class SPV3D_Renderer;
+class SPV3D_NonIsometricDlg;
+class SPV3D_UpdateRateDlg;
+class SPV3D_CubeAxesDlg;
+class SPV3D_SetRotationPointDlg;
+class SPV3D_InteractorStyle;
+class SPV3D_KeyFreeInteractorStyle;
+class SPV3D_ViewParameterDlg;
+class SPV3D_Recorder;
+
+namespace salomevtk
+{
+ class vtkPVAxesWidget;
+}
+
+class vtkObject;
+class QtxAction;
+
+namespace SPV3D
+{
+ // SPV3D_EXPORT
+ // int convertAction( const int );
+}
+
+//! Define a container for SALOME PV3D view window
+class SPV3D_EXPORT SPV3D_ViewWindow : public PV3DViewer_ViewWindow //SUIT_ViewWindow
+{
+ Q_OBJECT
+
+ public:
+ //! To construct #SPV3D_ViewWindow instance
+ SPV3D_ViewWindow(SUIT_Desktop* theDesktop, SPV3D_ViewModel* theModel);
+
+ virtual ~SPV3D_ViewWindow();
+
+ //virtual QImage dumpView();
+
+#if 0
+ //! To initialize #SPV3D_ViewWindow instance
+ virtual void Initialize(SPV3D_ViewModel/*Base*/* theModel);
+
+ //! Get #SPV3D_View
+ SPV3D_View* getView();
+
+ //! Get render window
+ vtkRenderWindow* getRenderWindow();
+
+ //! Get interactor
+ vtkRenderWindowInteractor* getInteractor() const;
+
+ //! Get SPV3D interactor
+ SPV3D_RenderWindowInteractor* GetInteractor() const;
+
+ //! Get current interactor style
+ vtkInteractorStyle* GetInteractorStyle() const;
+
+ //! Add interactor style to the stack of styles
+ void PushInteractorStyle(vtkInteractorStyle* theStyle);
+
+ //! Remove last interactor style from the stack of styles
+ void PopInteractorStyle();
+
+ //! Get renderer
+ vtkRenderer* getRenderer() const;
+
+ //! Get SPV3D renderer
+ SPV3D_Renderer* GetRenderer() const;
+#endif
+
+ //! Get selector
+ //SPV3D_Selector* GetSelector() const;
+
+#if 0
+ //! Set selection mode
+ Selection_Mode SelectionMode() const;
+
+ //! Change selection mode
+ virtual void SetSelectionMode(Selection_Mode theMode);
+
+ //! Set background color [obsolete]
+ virtual void setBackgroundColor( const QColor& );
+
+ //! Get background color [obsolete]
+ QColor backgroundColor() const;
+
+ //! Set background
+ virtual void setBackground( const Qtx::BackgroundData& );
+
+ //! Get background
+ Qtx::BackgroundData background() const;
+
+ //! Return \c true if "display trihedron" flag is set
+ bool isTrihedronDisplayed();
+
+ //! Return \c true if "show graduated axes" flag is set
+ bool isCubeAxesDisplayed();
+
+ /* interactive object management */
+ //! Redirect the request to #SPV3D_View::highlight (to support old code)
+ virtual void highlight(const Handle(SALOME_InteractiveObject)& theIO,
+ bool theIsHighlight = true,
+ bool theIsUpdate = true);
+
+ //! Redirect the request to #SPV3D_View::unHighlightAll (to support old code)
+ virtual void unHighlightAll();
+
+ //! Redirect the request to #SPV3D_View::isInViewer (to support old code)
+ bool isInViewer(const Handle(SALOME_InteractiveObject)& theIObject);
+
+ //! Redirect the request to #SPV3D_View::isVisible (to support old code)
+ bool isVisible(const Handle(SALOME_InteractiveObject)& theIObject);
+
+ //! Redirect the request to #SPV3D_View::FindIObject (to support old code)
+ //----------------------------------------------------------------------------
+ Handle(SALOME_InteractiveObject) FindIObject(const char* theEntry);
+#endif
+
+ /* display */
+ //----------------------------------------------------------------------------
+ //! Redirect the request to #SPV3D_View::Display (to support old code)
+ virtual void Display(const Handle(SALOME_InteractiveObject)& theIObject,
+ bool theImmediatly = true);
+
+ //! Redirect the request to #SPV3D_View::DisplayOnly (to support old code)
+ virtual void DisplayOnly(const Handle(SALOME_InteractiveObject)& theIObject);
+
+ //! Redirect the request to #SPV3D_View::Erase (to support old code)
+ virtual void Erase(const Handle(SALOME_InteractiveObject)& theIObject,
+ bool theImmediatly = true);
+
+ //! Redirect the request to #SPV3D_View::DisplayAll (to support old code)
+ virtual void DisplayAll();
+
+ //! Redirect the request to #SPV3D_View::EraseAll (to support old code)
+ virtual void EraseAll();
+
+ //! To repaint the viewer
+ virtual void Repaint(bool theUpdateTrihedron = true);
+
+#if 0
+ //----------------------------------------------------------------------------
+ //! Redirect the request to #SPV3D_Renderer::SetScale
+ virtual void SetScale( double theScale[3] );
+
+ //! Redirect the request to #SPV3D_Renderer::GetScale
+ virtual void GetScale( double theScale[3] );
+
+ //! Redirect the request to #SPV3D_Renderer::AddActor
+ virtual void AddActor(PV3DViewer_Actor* theActor,
+ bool theIsUpdate = false,
+ bool theIsAdjustActors = true);
+
+ //! Redirect the request to #SPV3D_Renderer::RemoveActor
+ virtual void RemoveActor(PV3DViewer_Actor* theActor,
+ bool theIsUpdate = false,
+ bool theIsAdjustActors = true);
+
+ //----------------------------------------------------------------------------
+ //! Redirect the request to #SPV3D_Renderer::AdjustActors
+ virtual void AdjustTrihedrons(const bool theIsForced);
+
+ //! Redirect the request to #SPV3D_Renderer::GetTrihedron
+ PV3DViewer_Trihedron* GetTrihedron();
+
+ //! Redirect the request to #SPV3D_Renderer::GetCubeAxes
+ SPV3D_CubeAxesActor2D* GetCubeAxes();
+
+ //! Redirect the request to #SPV3D_Renderer::GetTrihedronSize
+ double GetTrihedronSize() const;
+
+ //! Redirect the request to #SPV3D_Renderer::SetTrihedronSize
+ virtual void SetTrihedronSize( const double, const bool = true );
+
+ //! Set incremental speed
+ virtual void SetIncrementalSpeed( const int, const int = 0 );
+
+ //! Set current projection mode
+ virtual void SetProjectionMode( const int );
+
+ //! Sets stereo type
+ virtual void SetStereoType( const int );
+
+ //! Sets anaglyph filter
+ virtual void SetAnaglyphFilter( const int );
+
+ //! Set support quad-buffered stereo
+ virtual void SetQuadBufferSupport( const bool );
+
+ //! Set interactive style
+ virtual void SetInteractionStyle( const int );
+
+ //! Set zooming style
+ virtual void SetZoomingStyle( const int );
+
+ //! Set preselection mode
+ virtual void SetPreSelectionMode( Preselection_Mode );
+#endif
+
+ //! Enable/disable selection
+ virtual void SetSelectionEnabled( bool );
+
+#if 0
+ //! Customize space mouse buttons
+ virtual void SetSpacemouseButtons( const int, const int, const int );
+
+ //! Set selection properties
+ virtual void SetSelectionProp(const double& theRed = 1,
+ const double& theGreen = 1,
+ const double& theBlue = 0,
+ const int& theWidth = 5);
+
+ //! Redirect the request to #SPV3D_Renderer::SetPreselectionProp
+ virtual void SetPreselectionProp(const double& theRed = 0,
+ const double& theGreen = 1,
+ const double& theBlue = 1,
+ const int& theWidth = 5);
+
+ //! Redirect the request to #SPV3D_Renderer::SetSelectionTolerance
+ virtual void SetSelectionTolerance(const double& theTolNodes = 0.025,
+ const double& theTolCell = 0.001,
+ const double& theTolObjects = 0.025);
+
+ //! Get visibility status of the static trihedron
+ bool IsStaticTrihedronVisible() const;
+
+ //! Set visibility status of the static trihedron
+ virtual void SetStaticTrihedronVisible( const bool );
+
+ //! Methods to save/restore visual parameters of a view (pan, zoom, etc.)
+ virtual QString getVisualParameters();
+
+ virtual void setVisualParameters( const QString& parameters );
+
+ virtual bool eventFilter( QObject*, QEvent* );
+
+ virtual void RefreshDumpImage();
+
+ void emitTransformed();
+
+ //! To invoke a PV3D event on #SPV3D_RenderWindowInteractor instance
+ void InvokeEvent(unsigned long theEvent, void* theCallData);
+
+ virtual SUIT_CameraProperties cameraProperties();
+#endif
+
+ signals:
+ void Show( QShowEvent * );
+ void Hide( QHideEvent * );
+
+public slots:
+ virtual void showEvent( QShowEvent * );
+ virtual void hideEvent( QHideEvent * );
+
+#if 0
+ virtual void onSelectionChanged();
+
+ void onChangeRotationPoint(bool theIsActivate);
+
+ void activateSetRotationGravity();
+ void activateSetRotationSelected(void* theData);
+ void activateStartPointSelection( Selection_Mode );
+
+ void onUpdateRate(bool theIsActivate);
+ void onNonIsometric(bool theIsActivate);
+ void onGraduatedAxes(bool theIsActivate);
+
+ void activateZoom();
+ void activateWindowFit();
+ void activateRotation();
+ void activatePanning();
+ void activateGlobalPanning();
+
+ void onProjectionMode( QAction* theAction );
+ void onStereoMode( bool activate );
+ void onProjectionMode();
+
+ void activateProjectionMode(int);
+
+ void activateSetFocalPointGravity();
+ void activateSetFocalPointSelected();
+ void activateStartFocalPointSelection();
+ void activateInteractiveSelection();
+ void deactivateCurrectOperation();
+
+ void onViewParameters(bool theIsActivate);
+
+ void onSwitchInteractionStyle(bool theOn);
+ void onSwitchZoomingStyle(bool theOn);
+
+ void onSwitchPreSelectionMode(int theMode);
+ void onEnableSelection(bool theOn);
+
+ void onStartRecording();
+ void onPlayRecording();
+ void onPauseRecording();
+ void onStopRecording();
+
+signals:
+ void selectionChanged();
+ void actorAdded(PV3DViewer_Actor*);
+ void actorRemoved(PV3DViewer_Actor*);
+ void transformed(SPV3D_ViewWindow*);
+
+public slots:
+ //! Redirect the request to #SPV3D_Renderer::OnFrontView
+ virtual void onFrontView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnBackView
+ virtual void onBackView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnTopView
+ virtual void onTopView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnBottomView
+ virtual void onBottomView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnRightView
+ virtual void onRightView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnLeftView
+ virtual void onLeftView();
+
+ //! Redirect the request to #SPV3D_Renderer::onClockWiseView
+ virtual void onClockWiseView();
+
+ //! Redirect the request to #SPV3D_Renderer::onAntiClockWiseView
+ virtual void onAntiClockWiseView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnResetView
+ virtual void onResetView();
+
+ //! Redirect the request to #SPV3D_Renderer::OnFitAll
+ virtual void onFitAll();
+
+ //! Redirect the request to #SPV3D_Renderer::OnFitSelection
+ virtual void onFitSelection();
+
+ //! Redirect the request to #SPV3D_Renderer::OnFitIObjects
+ virtual void onFitIObjects(const SALOME_ListIO&);
+
+ //! Redirect the request to #SPV3D_Renderer::OnViewTrihedron
+ virtual void onViewTrihedron(bool);
+
+ //! Redirect the request to #SPV3D_Renderer::OnViewCubeAxes
+ virtual void onViewCubeAxes();
+
+ //! Redirect the request to #SPV3D_Renderer::OnAdjustTrihedron
+ virtual void onAdjustTrihedron();
+
+ //! Redirect the request to #SPV3D_Renderer::OnAdjustCubeAxes
+ virtual void onAdjustCubeAxes();
+
+ virtual void synchronize(SPV3D_ViewWindow*);
+#endif
+
+protected slots:
+ //void synchronize( SUIT_ViewWindow* );
+ void onKeyPressed(QKeyEvent* event);
+ void onKeyReleased(QKeyEvent* event);
+ void onMousePressed(QMouseEvent* event);
+ void onMouseDoubleClicked(QMouseEvent* event);
+ void onMouseReleased(QMouseEvent* event);
+ void onMouseMoving(QMouseEvent* event);
+
+public:
+#if 0
+ enum ProjectionType { Parallel, Projection, Stereo };
+
+ enum StereoType { CrystalEyes, RedBlue, Interlaced, Left, Right, Dresden, Anaglyph, Checkerboard, SplitViewPortHorizontal };
+
+ enum AnaglyphFilter { RedCyan, YellowBlue, GreenMagenta };
+#endif
+
+protected:
+
+ // virtual void resizeEvent( QResizeEvent* );
+
+ // virtual void Initialize(SPV3D_View* theView,
+ // SPV3D_ViewModel/*Base*/* theModel);
+
+#if 0
+ // Main process event method
+ static void ProcessEvents(vtkObject* object,
+ unsigned long event,
+ void* clientdata,
+ void* calldata);
+
+ bool isOpenGlStereoSupport() const;
+
+ void doSetVisualParameters( const QString&, bool = false );
+ void SetEventDispatcher(vtkObject* theDispatcher);
+
+ QImage dumpViewContent();
+
+ virtual QString filter() const;
+ virtual bool dumpViewToFormat( const QImage& img, const QString& fileName, const QString& format );
+
+ virtual bool action( const int );
+
+ QtxAction* getAction( int ) const;
+ void createToolBar();
+ void createActions(SUIT_ResourceMgr* theResourceMgr);
+
+ enum { DumpId, FitAllId, FitRectId, FitSelectionId, ZoomId, PanId, GlobalPanId,
+ ChangeRotationPointId, RotationId,
+ FrontId, BackId, TopId, BottomId, LeftId, RightId, ClockWiseId, AntiClockWiseId, ResetId,
+ ViewTrihedronId, NonIsometric, GraduatedAxes, UpdateRate,
+ ParallelModeId, ProjectionModeId, StereoModeId, ViewParametersId, SynchronizeId, SwitchInteractionStyleId,
+ SwitchZoomingStyleId,
+ PreselectionId, StandardPreselectionId, DynamicPreselectionId, DisablePreselectionId,
+ EnableSelectionId,
+ StartRecordingId, PlayRecordingId, PauseRecordingId, StopRecordingId };
+#endif
+
+ SPV3D_View* myView;
+ SPV3D_ViewModel/*Base*/* myModel;
+
+// SPV3D_RenderWindowInteractor* myInteractor;
+// vtkSmartPointer<SPV3D_InteractorStyle> myDefaultInteractorStyle;
+// vtkSmartPointer<SPV3D_KeyFreeInteractorStyle> myKeyFreeInteractorStyle;
+
+// QString myVisualParams; // used for delayed setting of view parameters
+
+// vtkSmartPointer<vtkObject> myEventDispatcher;
+
+// // Used to process events
+// vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
+
+// SPV3D_NonIsometricDlg* myNonIsometricDlg;
+// SPV3D_UpdateRateDlg* myUpdateRateDlg;
+// SPV3D_CubeAxesDlg* myCubeAxesDlg;
+// SPV3D_SetRotationPointDlg* mySetRotationPointDlg;
+// SPV3D_ViewParameterDlg* myViewParameterDlg;
+
+// QSize myPreRecordingMinSize;
+// QSize myPreRecordingMaxSize;
+
+// SPV3D_Recorder* myRecorder;
+// QtxAction* myStartAction;
+// QtxAction* myPlayAction;
+// QtxAction* myPauseAction;
+// QtxAction* myStopAction;
+
+// int myToolBar;
+// int myRecordingToolBar;
+
+// salomevtk::vtkPVAxesWidget* myAxesWidget;
+// Qtx::BackgroundData myBackground;
+
+// private:
+// QImage myDumpImage;
+};
+
+#ifdef WIN32
+#pragma warning( default:4251 )
+#endif
+
+#endif
ENDIF(SALOME_USE_SALOMEOBJECT)
ENDIF()
+# MBS:
+IF(SALOME_USE_PV3DVIEWER)
+ LIST(APPEND _link_LIBRARIES PV3DViewer)
+ IF(SALOME_USE_SALOMEOBJECT)
+ LIST(APPEND _link_LIBRARIES SPV3D)
+ ENDIF(SALOME_USE_SALOMEOBJECT)
+ENDIF()
+
IF(SALOME_USE_PVVIEWER)
LIST(APPEND _link_LIBRARIES PVViewer)
ENDIF()
