//
// File : PVGUI_Module.cxx
+#define PARAVIS_MODULE_NAME "PARAVIS"
+
#include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
#ifdef HAVE_FINITE
#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
#include <vtkPython.h> // Python first
#include "PVGUI_Module.h"
-#ifdef PARAVIS_WITH_FULL_CORBA
-# include "PARAVIS_Gen_i.hh"
-#endif
+//#ifdef PARAVIS_WITH_FULL_CORBA
+//# include "PARAVIS_Gen_i.hh"
+//#endif
#include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
#include CORBA_SERVER_HEADER(SALOMEDS)
#include "PVViewer_ViewModel.h"
#include "PVGUI_Tools.h"
#include "PVGUI_ParaViewSettingsPane.h"
+#include "PVViewer_GUIElements.h"
+#include "PVViewer_EngineWrapper.h"
+#include "PVGUI_DataModel.h"
// SALOME Includes
+#include <utilities.h>
#include <SUIT_DataBrowser.h>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <LightApp_SelectionMgr.h>
#include <LightApp_NameDlg.h>
-#include <SalomeApp_Application.h>
+#include <LightApp_Application.h>
+#include <SalomeApp_Application.h> // should ultimately be a LightApp only
#include <SalomeApp_Study.h>
#include <SALOME_ListIO.hxx>
#include <SALOMEDS_Tool.hxx>
#include <pqServerResource.h>
#include <pqServerConnectReaction.h>
+// TO REMOVE:
+#include <PyInterp_Interp.h>
+
+#include <PVViewer_EngineWrapper.h>
+
+
//----------------------------------------------------------------------------
PVGUI_Module* ParavisModule = 0;
+PVSERVER_ORB::PVSERVER_Gen_var PVGUI_Module::MyEngine;
/*!
\mainpage
+ TODO TODO update this:
<h2>Building and installing PARAVIS</h2>
As any other SALOME module, PARAVIS requires PARAVIS_ROOT_DIR environment variable to be set to PARAVIS
_PTR(SComponent)
ClientFindOrCreateParavisComponent(_PTR(Study) theStudyDocument)
{
- _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("PARAVIS");
+ _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("PVSERVER");
if (!aSComponent) {
_PTR(StudyBuilder) aStudyBuilder = theStudyDocument->NewBuilder();
aStudyBuilder->NewCommand();
int aLocked = theStudyDocument->GetProperties()->IsLocked();
if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
- aSComponent = aStudyBuilder->NewComponent("PARAVIS");
+ aSComponent = aStudyBuilder->NewComponent("PVSERVER");
_PTR(GenericAttribute) anAttr =
aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
_PTR(AttributeName) aName (anAttr);
CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
SALOME_ModuleCatalog::ModuleCatalog_var Catalogue =
SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
- SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "PARAVIS" );
+ SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "PVSERVER" );
if (!Comp->_is_nil()) {
aName->SetValue(Comp->componentusername());
}
// Create Attribute parameters for future using
anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeParameter");
- aStudyBuilder->DefineComponentInstance(aSComponent, PVGUI_Module::GetEngine()->GetIOR());
+ aStudyBuilder->DefineComponentInstance(aSComponent, PVGUI_Module::GetCPPEngine()->GetIOR());
if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
aStudyBuilder->CommitCommand();
}
\brief Constructor. Sets the default name for the module.
*/
PVGUI_Module::PVGUI_Module()
- : SalomeApp_Module( "PARAVIS" ),
+ : SalomeApp_Module( PARAVIS_MODULE_NAME ),
mySelectionControlsTb( -1 ),
mySourcesMenuId( -1 ),
myFiltersMenuId( -1 ),
myTraceWindow(0),
myStateCounter(0),
myInitTimer(0),
- myPushTraceTimer(0)
+ myPushTraceTimer(0),
+ myGuiElements(0)
{
#ifdef HAS_PV_DOC
Q_INIT_RESOURCE( PVGUI );
delete myInitTimer;
}
-PARAVIS_ORB::PARAVIS_Gen_var PVGUI_Module::GetEngine()
+PVViewer_EngineWrapper * PVGUI_Module::GetEngine()
{
- return PVViewer_ViewManager::GetEngine();
+ return PVViewer_EngineWrapper::GetInstance();
+}
+
+PVSERVER_ORB::PVSERVER_Gen_var PVGUI_Module::GetCPPEngine()
+{
+ // initialize PARAVIS module engine (load, if necessary)
+ if ( CORBA::is_nil( MyEngine ) ) {
+ Engines::EngineComponent_var comp =
+ SalomeApp_Application::lcc()->FindOrLoad_Component( "FactoryServer", "PVSERVER" );
+ MyEngine = PVSERVER_ORB::PVSERVER_Gen::_narrow( comp );
+ }
+ return MyEngine;
+}
+
+/*!
+ \brief Create data model.
+ \return module specific data model
+*/
+CAM_DataModel* PVGUI_Module::createDataModel()
+{
+ return new PVGUI_DataModel( this );
}
pqPVApplicationCore * PVGUI_Module::GetPVApplication()
*/
void PVGUI_Module::initialize( CAM_Application* app )
{
- SalomeApp_Module::initialize( app );
+ LightApp_Module::initialize( app );
// Create ParaViS actions
createActions();
}
*/
- SalomeApp_Application* anApp = getApp();
+ LightApp_Application* anApp = getApp();
SUIT_Desktop* aDesktop = anApp->desktop();
// Initialize ParaView client and associated behaviors
// and connect to externally launched pvserver
- PVViewer_ViewManager::ParaviewInitApp(aDesktop);
+ PVViewer_ViewManager::ParaviewInitApp(aDesktop, anApp->logWindow());
+ myGuiElements = PVViewer_GUIElements::GetInstance(aDesktop);
// Remember current state of desktop toolbars
QList<QToolBar*> foreignToolbars = aDesktop->findChildren<QToolBar*>();
// Behaviors and connection must be instanciated *after* widgets are in place
// In PARAVIS module we do not wait for PVViewer_ViewWindow to be instanciated to have this:
PVViewer_ViewManager::ParaviewInitBehaviors(true, aDesktop);
- PVViewer_ViewManager::ConnectToExternalPVServer(aDesktop);
pvCreateActions();
- pvCreateToolBars();
pvCreateMenus();
+ pvCreateToolBars();
+
+ // Connect after toolbar creation, etc ... as some activations of the toolbars is triggered
+ // by the ServerConnection event:
+ PVViewer_ViewManager::ConnectToExternalPVServer(aDesktop);
QList<QDockWidget*> activeDocks = aDesktop->findChildren<QDockWidget*>();
QList<QMenu*> activeMenus = aDesktop->findChildren<QMenu*>();
updateMacros();
SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
- bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
+ bool isStop = aResourceMgr->booleanValue( PARAVIS_MODULE_NAME, "stop_trace", false );
if(!isStop)
{
// Start a timer to schedule asap:
- // - the connection to the server
// - the trace start
myInitTimer = new QTimer(aDesktop);
QObject::connect(myInitTimer, SIGNAL(timeout()), this, SLOT(onInitTimer()) );
}
/*!
- \brief Initialisation timer event - fired only once, after the GUI loop is ready.
- See creation in initialize().
+ \brief Initialisation timer event - trace start up
*/
void PVGUI_Module::onInitTimer()
{
-#ifndef PARAVIS_WITH_FULL_CORBA
-// connectToExternalPVServer();
-#endif
startTrace();
}
*/
void PVGUI_Module::showView( bool toShow )
{
- SalomeApp_Application* anApp = getApp();
+ LightApp_Application* anApp = getApp();
PVViewer_ViewManager* viewMgr =
dynamic_cast<PVViewer_ViewManager*>( anApp->getViewManager( PVViewer_Viewer::Type(), false ) );
if ( !viewMgr ) {
- viewMgr = new PVViewer_ViewManager( anApp->activeStudy(), anApp->desktop() );
+ viewMgr = new PVViewer_ViewManager( anApp->activeStudy(), anApp->desktop(), anApp->logWindow() );
anApp->addViewManager( viewMgr );
connect( viewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
anApp, SLOT( onCloseView( SUIT_ViewManager* ) ) );
storeCommonWindowsState();
- bool isDone = SalomeApp_Module::activateModule( study );
+ bool isDone = LightApp_Module::activateModule( study );
if ( !isDone ) return false;
- showView( true ); // this will also trigger the connection to the server
- // and the instanciation of the relevant PV behaviors
+ showView( true );
if ( mySourcesMenuId != -1 ) menuMgr()->show(mySourcesMenuId);
if ( myFiltersMenuId != -1 ) menuMgr()->show(myFiltersMenuId);
- if ( myFiltersMenuId != -1 ) menuMgr()->show(myMacrosMenuId);
- if ( myFiltersMenuId != -1 ) menuMgr()->show(myToolbarsMenuId);
+ if ( myMacrosMenuId != -1 ) menuMgr()->show(myMacrosMenuId);
+ if ( myToolbarsMenuId != -1 ) menuMgr()->show(myToolbarsMenuId);
+
+ // Update the various menus with the content pre-loaded in myGuiElements
+// QMenu* srcMenu = menuMgr()->findMenu( mySourcesMenuId );
+// myGuiElements->updateSourcesMenu(srcMenu);
+// QMenu* filtMenu = menuMgr()->findMenu( myFiltersMenuId );
+// myGuiElements->updateFiltersMenu(filtMenu);
+// QMenu* macMenu = menuMgr()->findMenu( myMacrosMenuId );
+// myGuiElements->updateMacrosMenu(macMenu);
+
setMenuShown( true );
setToolShown( true );
restoreCommonWindowsState();
- return SalomeApp_Module::deactivateModule( study );
+ return LightApp_Module::deactivateModule( study );
}
{
clearParaviewState();
- SalomeApp_Module::studyClosed(study);
+ LightApp_Module::studyClosed(study);
}
/*!
if(!studyDS) {
return;
}
-
- _PTR(SComponent) paravisComp =
- studyDS->FindComponent(GetEngine()->ComponentDataType());
+
+ _PTR(SComponent) paravisComp =
+ studyDS->FindComponent(PARAVIS_MODULE_NAME);
if(!paravisComp) {
return;
}
}
/*!
- \brief Returns IOR of current engine
+\brief Returns IOR of current engine
*/
QString PVGUI_Module::engineIOR() const
{
- CORBA::String_var anIOR = GetEngine()->GetIOR();
+ CORBA::String_var anIOR = GetCPPEngine()->GetIOR();
return QString(anIOR.in());
}
\brief Returns trace string
*/
static const QString MYReplaceStr("paraview.simple");
-static const QString MYReplaceImportStr("except: from pvsimple import *");
QString PVGUI_Module::getTraceString()
{
vtkSMTrace *tracer = vtkSMTrace::GetActiveTracer();
return QString("");
QString traceString(tracer->GetCurrentTrace());
+ std::stringstream nl; nl << std::endl; // surely there is some Qt trick to do that in a portable way??
+ QString end_line(nl.str().c_str());
+ // 'import pvsimple' is necessary to fix the first call to DisableFirstRenderCamera in the paraview trace
+ // 'ShowParaviewView()' ensure there is an opened viewing window (otherwise SEGFAULT!)
+ traceString = "import pvsimple" + end_line +
+ "pvsimple.ShowParaviewView()" + end_line + traceString;
// Replace import "paraview.simple" by "pvsimple"
if ((!traceString.isNull()) && traceString.length() != 0) {
traceString = traceString.replace(aPos, MYReplaceStr.length(), "pvsimple");
aPos = traceString.indexOf(MYReplaceStr, aPos);
}
- int aImportPos = traceString.indexOf(MYReplaceImportStr);
- if(aImportPos != -1)
- {
- traceString = traceString.replace(aImportPos, MYReplaceImportStr.length(), "except:\n import pvsimple\n from pvsimple import *");
- }
}
return traceString;
{
// Paraview settings tab
int aParaViewSettingsTab = addPreference( tr( "TIT_PVIEWSETTINGS" ) );
- int aPanel = addPreference(QString(), aParaViewSettingsTab, LightApp_Preferences::UserDefined, "PARAVIS", "");
+
+ setPreferenceProperty(aParaViewSettingsTab, "stretch", false );
+ int aPanel = addPreference(QString(), aParaViewSettingsTab, LightApp_Preferences::UserDefined, PARAVIS_MODULE_NAME, "");
+
setPreferenceProperty(aPanel, "content", (qint64)(new PVGUI_ParaViewSettingsPane()));
// Paravis settings tab
int aParaVisSettingsTab = addPreference( tr( "TIT_PVISSETTINGS" ) );
- addPreference( tr( "PREF_STOP_TRACE" ), aParaVisSettingsTab, LightApp_Preferences::Bool, "PARAVIS", "stop_trace");
+ addPreference( tr( "PREF_STOP_TRACE" ), aParaVisSettingsTab, LightApp_Preferences::Bool, PARAVIS_MODULE_NAME, "stop_trace");
+
+ addPreference( tr( "PREF_NO_EXT_PVSERVER" ), aParaVisSettingsTab, LightApp_Preferences::Bool, PARAVIS_MODULE_NAME, "no_ext_pv_server");
int aSaveType = addPreference(tr( "PREF_SAVE_TYPE_LBL" ), aParaVisSettingsTab,
LightApp_Preferences::Selector,
- "PARAVIS", "savestate_type");
+ PARAVIS_MODULE_NAME, "savestate_type");
QList<QVariant> aIndices;
QStringList aStrings;
aIndices<<0<<1<<2;
*/
void PVGUI_Module::contextMenuPopup(const QString& theClient, QMenu* theMenu, QString& theTitle)
{
- SalomeApp_Module::contextMenuPopup(theClient, theMenu, theTitle);
-
+ LightApp_Module::contextMenuPopup(theClient, theMenu, theTitle);
+
// Check if we are in Object Browser
SUIT_DataBrowser* ob = getApp()->objectBrowser();
bool isOBClient = (ob && theClient == ob->popupClientType());
aSelectionMgr->selectedObjects(aListIO);
if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
QString entry = QString(aListIO.First()->getEntry());
-
+
// Get active study
- SalomeApp_Study* activeStudy =
+ SalomeApp_Study* activeStudy =
dynamic_cast<SalomeApp_Study*>(getApp()->activeStudy());
if(!activeStudy) {
return;
}
- // Get SALOMEDS client study
+ // Get SALOMEDS client study
_PTR(Study) studyDS = activeStudy->studyDS();
if(!studyDS) {
return;
}
- QString paravisDataType(GetEngine()->ComponentDataType());
- if(activeStudy && activeStudy->isComponent(entry) &&
+ QString paravisDataType(PARAVIS_MODULE_NAME);
+ if(activeStudy && activeStudy->isComponent(entry) &&
activeStudy->componentDataType(entry) == paravisDataType) {
// ParaViS module object
theMenu->addSeparator();
}
else {
// Try to get state object
- _PTR(SObject) stateSObj =
+ _PTR(SObject) stateSObj =
studyDS->FindObjectID(entry.toLatin1().constData());
if (!stateSObj) {
return;
}
-
+
// Check local id
_PTR(GenericAttribute) anAttr;
if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
}
_PTR(AttributeLocalID) anID(anAttr);
-
+
if (anID->Value() == PVSTATEID) {
// Paraview state object
theMenu->addSeparator();
startTrace();
}
-/*!
- \brief Show ParaView view.
-*/
-void PVGUI_Module::onNewParaViewWindow()
-{
- showView(true);
-}
-
/*!
\brief Save state under the module root object.
*/
if(!studyDS) {
return;
}
-
+
_PTR(SComponent) paravisComp =
- studyDS->FindComponent(GetEngine()->ComponentDataType());
+ studyDS->FindComponent(PARAVIS_MODULE_NAME);
if(!paravisComp) {
return;
}
void PVGUI_Module::onPushTraceTimer()
{
-// MESSAGE("onPushTraceTimer(): Pushing trace to engine...");
+ //MESSAGE("onPushTraceTimer(): Pushing trace to engine...");
GetEngine()->PutPythonTraceStringToEngine(getTraceString().toStdString().c_str());
}
