#include <qfileinfo.h>
#include "Utils_ExceptHandlers.hxx"
+/*! SAN & VSR : Test QT_EVENT
+ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+*/
+#include "SALOME_Event.hxx"
+
+#include "QAD_Config.h"
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "QAD_RightFrame.h"
+
+#include "VTKViewer_ViewFrame.h"
+
+#include <vtkActor.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkSphereSource.h>
+#include <vtkProperty.h>
+
+/*! SAN & VSR : Test QT_EVENT
+ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+*/
+
using namespace std;
static QFileInfo aFileInfo;
Engines_Component_i()
{
if(MYDEBUG) MESSAGE("VISU_Gen_i::VISU_Gen_i : "<<theMutex);
- Mutex mt(theMutex,qApp);
+ Mutex mt(theMutex);
Base_i::myMutex = theMutex; //apo
Base_i::myOrb = CORBA::ORB::_duplicate(theORB);
Base_i::myPoa = PortableServer::POA::_duplicate(thePOA);
{
if(MYDEBUG) MESSAGE("VISU_Gen_i::Load - myMutex = "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
SALOMEDS::Study_var aStudy = theComponent->GetStudy();
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
TCollection_AsciiString aTmpDir =
if(myMutex){
CORBA::String_var aString("");
if(strcmp(aLocalPersistentID,"") != 0) {
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
Storable* aStorable =
Storable::Create(theSObject,VisuTmpDir.c_str(),aLocalPersistentID);
if(aStorable != NULL) aString = aStorable->GetID();
{
if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - myMutex = "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
TCollection_AsciiString aTmpDir = isMultiFile? strdup(theURL): SALOMEDS_Tool::GetTmpDir();
if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - "<<aTmpDir);
int aCounter = 0;
bool isMultiFile) {
if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - myMutex = "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
CORBA::String_var aString = SALOMEDS_Tool::GetTmpDir();
TCollection_AsciiString aTmpDir = isMultiFile? (const Standard_CString)theURL: (const Standard_CString)aString.in();
if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - "<<aTmpDir);
if(!CORBA::is_nil(anObj)){
Storable* pStorable = dynamic_cast<Storable*>(GetServant(anObj).in());
if(pStorable != NULL){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
aString = pStorable->ToString().c_str();
return aString._retn();
}
//omni_mutex_lock aMutexLock(aMutex);
if(MYDEBUG) MESSAGE("VISU_Gen_i::GetViewManager : "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
ViewManager_i * aViewManager = new ViewManager_i(myStudyDocument);
return ViewManager::_duplicate(aViewManager->_this());
}
SALOMEDS::SObject_ptr VISU_Gen_i::ImportTables(const char* theFileName){
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return SALOMEDS::SObject::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
SALOMEDS::SObject_var aRes = VISU::ImportTables(theFileName,myStudyDocument);
return aRes._retn();
}
Result_ptr VISU_Gen_i::ImportFile(const char* theFileName){
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
aFileInfo.setFile(theFileName);
Result_i* pResult = new Result_i(myStudyDocument);
if(pResult->Create(theFileName) != NULL)
Result_ptr VISU_Gen_i::CopyAndImportFile(const char* theFileName){
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
VISU::Result_var aResult;
aFileInfo.setFile(theFileName);
Result_i* pResult = new Result_i(myStudyDocument,Result_i::eRestoredFile);
if(MYDEBUG) MESSAGE("VISU_Gen_i::ImportMed : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
Result_i* pResult = new Result_i(myStudyDocument);
if(pResult->Create(theMedSObject) != NULL)
return pResult->_this();
if(MYDEBUG) MESSAGE("VISU_Gen_i::ImportMedField : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
Result_i* pResult = new Result_i(myStudyDocument);
if(pResult->Create(theField) != NULL)
return pResult->_this();
if(MYDEBUG) MESSAGE("VISU_Gen_i::MeshOnEntity : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Mesh::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in());
- Mesh_i* aPresent = new Mesh_i(pResult);
- if(aPresent->Create(theMeshName,theEntity) != NULL)
- return aPresent->_this();
- else{
- aPresent->_remove_ref();
- return VISU::Mesh::_nil();
+ Mutex mt(myMutex);
+ if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
+ Mesh_i* aPresent = new Mesh_i(pResult);
+ if(aPresent->Create(theMeshName,theEntity) != NULL)
+ return aPresent->_this();
+ else{
+ aPresent->_remove_ref();
+ return VISU::Mesh::_nil();
+ }
}
}
return myVisuGen->MeshOnEntity(theResult,theMeshName,theEntity);
if(MYDEBUG) MESSAGE("VISU_Gen_i::FamilyMeshOnEntity : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Mesh::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in());
- Mesh_i* aPresent = new Mesh_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFamilyName) != NULL)
- return aPresent->_this();
- else{
- aPresent->_remove_ref();
- return VISU::Mesh::_nil();
+ Mutex mt(myMutex);
+ if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
+ Mesh_i* aPresent = new Mesh_i(pResult);
+ if(aPresent->Create(theMeshName,theEntity,theFamilyName) != NULL)
+ return aPresent->_this();
+ else{
+ aPresent->_remove_ref();
+ return VISU::Mesh::_nil();
+ }
}
}
return myVisuGen->FamilyMeshOnEntity(theResult,theMeshName,theEntity,theFamilyName);
if(MYDEBUG) MESSAGE("VISU_Gen_i::GroupMesh : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Mesh::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in());
- Mesh_i* aPresent = new Mesh_i(pResult);
- if(aPresent->Create(theMeshName,theGroupName) != NULL)
- return aPresent->_this();
- else{
- aPresent->_remove_ref();
- return VISU::Mesh::_nil();
+ Mutex mt(myMutex);
+ if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
+ Mesh_i* aPresent = new Mesh_i(pResult);
+ if(aPresent->Create(theMeshName,theGroupName) != NULL)
+ return aPresent->_this();
+ else{
+ aPresent->_remove_ref();
+ return VISU::Mesh::_nil();
+ }
}
}
return myVisuGen->GroupMesh(theResult,theMeshName,theGroupName);
if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateTable : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Table::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
Table_i* pPresent = new Table_i(myStudyDocument,theTableEntry);
if(pPresent->Create() != NULL)
return pPresent->_this();
if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateCurve : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Curve::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
PortableServer::POA_ptr aPOA = GetPOA();
Table_i* pTable = dynamic_cast<Table_i*>(aPOA->reference_to_servant(theTable));
Curve_i* pPresent = new Curve_i(myStudyDocument,pTable,theHRow,theVRow);
if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateContainer : "<<myMutex);
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Container::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
Container_i* pPresent = new Container_i(myStudyDocument);
if(pPresent->Create() != NULL)
return pPresent->_this();
Animation_ptr VISU_Gen_i::CreateAnimation(View3D_ptr theView3D){
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Animation::_nil();
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
if(MYDEBUG) MESSAGE("VISU_Gen_i::CreateAnimation : "<<myMutex);
- if(VISU_TimeAnimation* anAnim = new VISU_TimeAnimation(myStudyDocument,theView3D)){
+ if(VISU_TimeAnimation_i* anAnim = new VISU_TimeAnimation_i(myStudyDocument,theView3D)){
return anAnim->_this();
}else
return VISU::Animation::_nil();
void VISU_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent){
if(MYDEBUG) MESSAGE("VISU_Gen_i::Close : "<<myMutex);
if(myMutex){
- //Mutex mt(myMutex,qApp);
+ //Mutex mt(myMutex);
//SALOMEDS::Study_var aStudy = theComponent->GetStudy();
//if(!aStudy->_is_nil()){
// SALOMEDS::ChildIterator_var aChildIter = aStudy->NewChildIterator(theComponent);
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("VISU_Gen_i::PublishInStudy : "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
SALOMEDS::SObject_var aResultSO;
Result_i* aResultObj = dynamic_cast<Result_i*>(GetServant(theObject).in());
if (!aResultObj) return aResultSO._retn();
CORBA::Boolean VISU_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
if(0 && MYDEBUG) MESSAGE("VISU_Gen_i::CanCopy : "<<myMutex);
if(myMutex){
- //Mutex mt(myMutex,qApp);
+ //Mutex mt(myMutex);
SALOMEDS::GenericAttribute_var anAttr;
if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return false;
try {
SALOMEDS::TMPFile* VISU_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) {
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
theObjectID = 0;
SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile;
SALOMEDS::SObject_ptr theObject) {
if(MYDEBUG) MESSAGE("VISU_Gen_i::PasteInto : "<<myMutex);
if(myMutex){
- Mutex mt(myMutex,qApp);
+ Mutex mt(myMutex);
SALOMEDS::SObject_var aResultSO;
if (theObjectID != 1) return aResultSO._retn();
return myVisuGen->PasteInto(theStream,theObjectID,theObject);
}
+ /*! SAN & VSR : Test QT_EVENT
+ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+ */
+ class TestViewEvent : public SALOME_Event {
+ public:
+ virtual bool Execute(){
+ QAD_Desktop* desktop = QAD_Application::getDesktop();
+ QAD_Study* aStudy = desktop->getActiveStudy();
+ if ( !aStudy ) {
+ QString defViewer = QAD_CONFIG->getSetting( "Viewer::DefaultViewer" );
+ int dv = defViewer.toInt();
+ QAD_CONFIG->addSetting( "Viewer::DefaultViewer", QString::number( VIEW_VTK ) );
+ desktop->createStudy();
+ if ( !defViewer.isEmpty() ) {
+ QAD_CONFIG->addSetting( "Viewer::DefaultViewer", QString::number( dv ) );
+ }
+ }
+ else {
+ aStudy->newWindow3d( "", VIEW_VTK );
+ }
+ return true;
+ }
+ };
+
+ class TestObjectEvent : public SALOME_Event {
+ public:
+ virtual bool Execute(){
+ float aRadius = 150.0 * random() / RAND_MAX + 10.;
+ float aX = 1000.0 * random() / RAND_MAX - 500.;
+ float aY = 1000.0 * random() / RAND_MAX - 500.;
+ float aZ = 1000.0 * random() / RAND_MAX - 500.;
+ float aR = (float)random() / RAND_MAX;
+ float aG = (float)random() / RAND_MAX;
+ float aB = (float)random() / RAND_MAX;
+
+ vtkSphereSource* aSource = vtkSphereSource::New();
+ aSource->SetRadius( aRadius );
+ aSource->SetCenter( aX, aY, aZ );
+
+ vtkProperty* prop = vtkProperty::New();
+ prop->SetColor( aR, aG, aB );
+
+ vtkPolyDataMapper* aMapper = vtkPolyDataMapper::New();
+ aMapper->SetInput( aSource->GetOutput() );
+
+ vtkActor* sphere = vtkActor::New();
+ sphere->SetMapper( aMapper );
+ sphere->SetProperty( prop );
+
+ QAD_Desktop* desktop = QAD_Application::getDesktop();
+ QAD_Study* aStudy = desktop->getActiveStudy();
+ if ( !aStudy ) {
+ return false;
+ }
+ VTKViewer_ViewFrame* vf = (VTKViewer_ViewFrame*)(desktop->getActiveStudy()->getActiveStudyFrame()->getRightFrame()->getViewFrame());
+ sphere->SetVisibility( true );
+ vf->getRenderer()->AddActor(sphere);
+ vf->Repaint();
+ return true;
+ }
+ };
+
+ void VISU_Gen_i::CreateTestView() {
+ if(myMutex){
+ TestViewEvent* ve = new TestViewEvent();
+ ve->process();
+ ve->release();
+ return;
+ }
+ myVisuGen->CreateTestView();
+ }
+
+ void VISU_Gen_i::ShowTestObject() {
+ if(myMutex){
+ TestObjectEvent* ve = new TestObjectEvent();
+ ve->process();
+ ve->release();
+ return;
+ }
+ myVisuGen->ShowTestObject();
+ }
+ /*! SAN & VSR : Test QT_EVENT
+ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+ */
};
#include "VISU_ScalarBarActor.hxx"
#include "VISU_Actor.h"
+#include "SALOME_Event.hxx"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Tools.h"
using namespace std;
#ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
#else
static int MYDEBUG = 0;
#endif
namespace VISU{
//===========================================================================
+ typedef TVoidMemFunEvent<QAD_StudyFrame> TFrameActionEvent;
+
+ template<class TObject>
+ class TSetBackgroundEvent: public SALOME_Event{
+ TObject* myView;
+ const SALOMEDS::Color& myColor;
+ public:
+ TSetBackgroundEvent(TObject* theView, const SALOMEDS::Color& theColor):
+ myView(theView), myColor(theColor)
+ {}
+ virtual bool Execute(){
+ int aColor[3];
+ aColor[0] = int(255.0*myColor.R);
+ aColor[1] = int(255.0*myColor.G);
+ aColor[2] = int(255.0*myColor.B);
+ QColor aNewColor(aColor[0],aColor[1],aColor[2]);
+ myView->setBackgroundColor(aNewColor);
+ return true;
+ }
+ };
+
+
+ class TSavePictureEvent: public SALOME_Event{
+ QWidget* myWidget;
+ const char* myFileName;
+ public:
+ typedef CORBA::Boolean TResult;
+ TResult myResult;
+ TSavePictureEvent(QWidget* theWidget, const char* theFileName):
+ myWidget(theWidget),
+ myFileName(theFileName),
+ myResult(false)
+ {}
+ virtual bool Execute(){
+ if(myWidget){
+ QPixmap px = QPixmap::grabWindow(myWidget->winId());
+ if (!QString(myFileName).isNull()) {
+ QString fmt = QAD_Tools::getFileExtensionFromPath(myFileName).upper();
+ if (fmt.isEmpty())
+ fmt = QString("BMP"); // default format
+ if (fmt == "JPG")
+ fmt = "JPEG";
+ myResult = px.save(myFileName, fmt.latin1());
+ }
+ }
+ }
+ };
+
+
+ void RepaintView(QAD_StudyFrame* theStudyFrame);
+ class TRepaintViewEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ public:
+ TRepaintViewEvent(QAD_StudyFrame* theStudyFrame):
+ myStudyFrame(theStudyFrame)
+ {}
+ virtual bool Execute(){
+ RepaintView(myStudyFrame);
+ return true;
+ }
+ };
+
+
VTKViewer_ViewFrame* GetViewFrame(QAD_StudyFrame* theStudyFrame){
return dynamic_cast<VTKViewer_ViewFrame*>(theStudyFrame->getRightFrame()->getViewFrame());
}
vtkCamera* GetCamera(QAD_StudyFrame* theStudyFrame){
return GetRenderer(theStudyFrame)->GetActiveCamera();
}
+
+
void RepaintView(QAD_StudyFrame* theStudyFrame){
GetRenderer(theStudyFrame)->ResetCameraClippingRange();
GetViewFrame(theStudyFrame)->getRW()->getRenderWindow()->Render();
//GetViewFrame(theStudyFrame)->Repaint();
}
+
+
VISU_Actor* UpdateViewer(QAD_StudyFrame* theStudyFrame, int theDisplaing, Prs3d_i* thePrs){
VTKViewer_ViewFrame* vf = GetViewFrame(theStudyFrame);
if (!vf) return NULL;
}
}
}
- //===========================================================================
- /*
- #include <qthread.h>
- class TViewManager: public QThread{
- public:
- TViewManager(SALOMEDS::Study_ptr theStudy) : myStudyDocument(theStudy) {};
- virtual void run(){
- qApp->lock();
- QAD_Desktop* aDesktop = QAD_Application::getDesktop();
- QAD_Study* aStudy = aDesktop->findStudy(myStudyDocument);
- if(!aStudy){
- CORBA::String_var aName = myStudyDocument->Name();
- aFileInfo.setFile(aName.in());
+
+ QAD_Study* CheckStudy( SALOMEDS::Study_ptr theStudy ) {
+ QAD_Desktop* aDesktop = QAD_Application::getDesktop();
+ QAD_Study* aStudy = aDesktop->findStudy(theStudy);
+ if(!aStudy){
+ CORBA::String_var aName = theStudy->Name();
+ aFileInfo.setFile(aName.in());
+ if (aFileInfo.exists())
aStudy = aDesktop->loadStudy(aFileInfo.baseName());
+ else
+ aStudy = aDesktop->loadStudy(aName.in());
+ if (!aStudy) {
+ MESSAGE("CheckStudy()::ERROR: Can't load study");
}
- qApp->unlock();
}
- SALOMEDS::Study_ptr myStudyDocument;
- };
- */
+ return aStudy;
+ }
+ //===========================================================================
ViewManager_i::ViewManager_i(SALOMEDS::Study_ptr theStudy) {
if(MYDEBUG) MESSAGE("ViewManager_i::ViewManager_i");
- Mutex mt(myMutex,qApp,MYDELAY);
myStudyDocument = SALOMEDS::Study::_duplicate(theStudy);
- //TViewManager* aTViewManager = new TViewManager(theStudy);
- //aTViewManager->start();
- QAD_Desktop* aDesktop = QAD_Application::getDesktop();
- QAD_Study* aStudy = aDesktop->findStudy(theStudy);
- if(!aStudy){
- CORBA::String_var aName = theStudy->Name();
- aFileInfo.setFile(aName.in());
- if (aFileInfo.exists())
- aStudy = aDesktop->loadStudy(aFileInfo.baseName());
- else aStudy = aDesktop->loadStudy(aName.in());
- if (!aStudy)
- MESSAGE("ViewManager_i::ERROR: Can't load study");
- }
}
- VISU::View3D_ptr ViewManager_i::Create3DView(){
- Mutex mt(myMutex,qApp,MYDELAY);
- if(MYDEBUG) MESSAGE("ViewManager_i::Create3DView");
- VISU::View3D_i* pView = new View3D_i(myStudyDocument);
- if(pView->Create(1) != NULL)
- return VISU::View3D::_duplicate(pView->_this());
- return VISU::View3D::_nil();
+ VISU::View_ptr ViewManager_i::GetCurrentView(){
+ class TEvent: public SALOME_Event{
+ SALOMEDS::Study_ptr myStudyDocument;
+ public:
+ TEvent( SALOMEDS::Study_ptr theStudy):
+ myStudyDocument(theStudy)
+ {}
+ virtual bool Execute(){
+ if(QAD_Study* aStudy = QAD_Application::getDesktop()->findStudy( myStudyDocument )){
+ if ( QAD_StudyFrame* aStudyFrame = aStudy->getActiveStudyFrame() ) {
+ if(MYDEBUG)
+ MESSAGE("GetCurrentView::Execute - TypeView = "<<aStudyFrame->getTypeView());
+ if ( aStudyFrame->getTypeView() == VIEW_VTK ) {
+ VISU::View3D_i* pView = new View3D_i(myStudyDocument);
+ if(pView->Create(0))
+ myResult = pView->_this();
+ } else if ( aStudyFrame->getTypeView() == VIEW_PLOT2D ) {
+ VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument);
+ if(pView->Create(0))
+ myResult = pView->_this();
+ }
+ }
+ }
+ return true;
+ }
+ typedef VISU::View_var TResult;
+ TResult myResult;
+ };
+ TEvent* ve = new TEvent( myStudyDocument );
+ ve->process();
+ TEvent::TResult aResult = ve->myResult;
+ ve->release();
+ return aResult._retn();
}
+
+
+ class TCreateViewEvent: public SALOME_Event{
+ public:
+ TCreateViewEvent( SALOMEDS::Study_ptr theStudy):
+ myStudyDocument(theStudy)
+ {};
+ protected:
+ SALOMEDS::Study_ptr myStudyDocument;
+ };
- VISU::View_ptr ViewManager_i::GetCurrentView(){
- Mutex mt(myMutex,qApp,MYDELAY);
- QAD_Study* Study = QAD_Application::getDesktop()->findStudy( myStudyDocument );
- if(MYDEBUG) MESSAGE("ViewManager_i::GetCurrent3DView - Study = "<<Study);
- QAD_StudyFrame* StudyFrame;
- if ( Study && ( StudyFrame = Study->getActiveStudyFrame() ) ) {
- if(MYDEBUG)
- MESSAGE("ViewManager_i::GetCurrent3DView - TypeView = "<<StudyFrame->getTypeView());
- if ( StudyFrame->getTypeView() == VIEW_VTK ) {
- VISU::View3D_i* pView = new View3D_i(myStudyDocument);
- if(pView->Create(0) != NULL)
- return VISU::View3D::_duplicate(pView->_this());
- }
- else if ( StudyFrame->getTypeView() == VIEW_PLOT2D ) {
- VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument);
- if(pView->Create(0) != NULL)
- return VISU::XYPlot::_duplicate(pView->_this());
+ template<class TViewFrame>
+ class TCreateViewFrameEvent: public TCreateViewEvent{
+ public:
+ typedef typename TViewFrame::TInterface TInterface;
+ typedef typename TInterface::_ptr_type TResult;
+ TResult myResult;
+ TCreateViewFrameEvent(SALOMEDS::Study_ptr theStudy):
+ TCreateViewEvent(theStudy),
+ myResult(TInterface::_nil())
+ {}
+ virtual bool Execute(){
+ if(CheckStudy(myStudyDocument)){
+ TViewFrame* pView = new TViewFrame(myStudyDocument);
+ if(pView->Create(1))
+ myResult = pView->_this();
}
+ return true;
}
- return VISU::View::_nil();
- }
+ };
+
+ VISU::View3D_ptr ViewManager_i::Create3DView(){
+ if(MYDEBUG) MESSAGE("ViewManager_i::Create3DView");
+ return ProcessEvent(new TCreateViewFrameEvent<VISU::View3D_i>(myStudyDocument));
+ }
+
VISU::XYPlot_ptr ViewManager_i::CreateXYPlot(){
if(MYDEBUG) MESSAGE("ViewManager_i::CreateXYPlot");
- Mutex mt(myMutex,qApp,MYDELAY);
- VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument);
- if(pView->Create(1) != NULL)
- return VISU::XYPlot::_duplicate(pView->_this());
- return VISU::XYPlot::_nil();
+ return ProcessEvent(new TCreateViewFrameEvent<VISU::XYPlot_i>(myStudyDocument));
}
VISU::TableView_ptr ViewManager_i::CreateTableView(VISU::Table_ptr theTable){
+ class TEvent: public TCreateViewEvent{
+ Table_ptr myTable;
+ public:
+ TEvent(SALOMEDS::Study_ptr theStudy,
+ Table_ptr theTable):
+ TCreateViewEvent(theStudy),
+ myTable(theTable)
+ {}
+ virtual bool Execute(){
+ if ( CheckStudy( myStudyDocument ) ) {
+ VISU::TableView_i* pView = new TableView_i(myStudyDocument);
+ if(pView->Create(myTable) != NULL)
+ myResult = pView->_this();
+ }
+ return true;
+ }
+ typedef VISU::TableView_var TResult;
+ TResult myResult;
+ };
if(MYDEBUG) MESSAGE("ViewManager_i::CreateTableView");
- Mutex mt(myMutex,qApp,MYDELAY);
- VISU::TableView_i* pView = new TableView_i(myStudyDocument);
- if(pView->Create(VISU::Table::_duplicate(theTable)) != NULL)
- return VISU::TableView::_duplicate(pView->_this());
- return VISU::TableView::_nil();
+ TEvent* ve = new TEvent(myStudyDocument,theTable);
+ ve->process();
+ TEvent::TResult aResult = ve->myResult;
+ ve->release();
+ return aResult._retn();
}
void ViewManager_i::Destroy(View_ptr theView){
- if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - "<<theView->_is_nil());
- if(theView->_is_nil()) return;
- CORBA::Object_var aView = VISU::View::_narrow(theView);
- if(!CORBA::is_nil(aView)){
- if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - VISU::View"<<(!CORBA::is_nil(aView)));
- VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(aView).in());
- if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - dynamic_cast"<<pView);
- if(pView) {
- pView->Close();
- pView->_remove_ref();
+ class TEvent: public SALOME_Event{
+ View_ptr myView;
+ public:
+ TEvent(View_ptr theView):
+ myView(theView)
+ {}
+ virtual bool Execute(){
+ if(!CORBA::is_nil(myView)){
+ if(VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(myView).in())) {
+ pView->Close();
+ pView->_remove_ref();
+ }
+ }
+ return true;
}
- //if(pView) delete pView;
- return;
- }
- }
-
-
- void ViewManager_i::ProcessEvents() {
- while (true) {
- qApp->lock();
- qApp->syncX();
- qApp->flushX();
- qApp->processEvents();
- qApp->unlock();
- //sleep(1);
- }
+ };
+ if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - "<<theView->_is_nil());
+ ProcessVoidEvent(new TEvent(theView));
}
View_i::View_i(SALOMEDS::Study_ptr theStudy) {
if(MYDEBUG) MESSAGE("View_i::View_i");
CORBA::String_var aName = theStudy->Name();
- QAD_Desktop* aDesktop = QAD_Application::getDesktop();
- myStudy = aDesktop->findStudy(theStudy);
- if(!myStudy){
- aFileInfo.setFile(aName.in());
- if ( aFileInfo.exists() )
- myStudy = aDesktop->loadStudy(aFileInfo.baseName());
- else myStudy = aDesktop->loadStudy(aName.in());
- }
+ myStudy = CheckStudy(theStudy);
if(MYDEBUG) MESSAGE("View_i::View_i - isStudyOpened = "<<myStudy<<"; aName = "<<aName.in());
}
const char* View_i::GetComment() const { return "";}
void View_i::ToStream(std::ostringstream& theStr) {}
- const char* View_i::GetEntry(){
+ string View_i::GetEntry(){
SALOMEDS::SObject_var aSObject = myStudy->getStudyDocument()->FindObjectIOR(GetID());
CORBA::String_var anEntry = aSObject->GetID();
- string aString(anEntry);
- if(MYDEBUG) MESSAGE("Result_i::GetEntry - "<<aString);
- return aString.c_str();
+ return string(anEntry.in());
}
+
+
//===========================================================================
XYPlot_i::XYPlot_i(SALOMEDS::Study_ptr theStudy) : View_i(theStudy) {
if(MYDEBUG) MESSAGE("XYPlot_i::XYPlot_i");
}
+
Storable* XYPlot_i::Create(int theNew){
- if(MYDEBUG) MESSAGE("XYPlot_i::Create");
- Mutex mt(myMutex,qApp,MYDELAY);
if(theNew)
myStudyFrame = myStudy->newWindow3d("",VIEW_PLOT2D);
else
myStudyFrame = myStudy->getActiveStudyFrame();
myView = dynamic_cast<Plot2d_ViewFrame*>(myStudyFrame->getRightFrame()->getViewFrame());
- Update();
+ myView->Repaint();
return this;
}
+
+
void XYPlot_i::Update() {
- if(MYDEBUG) MESSAGE("XYPlot_i::Update");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = (const char*)(myStudyFrame->title());
- myView->Repaint();
+ ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::Repaint));
}
+
+
void XYPlot_i::Close(){
- if(MYDEBUG) MESSAGE("XYPlot_i::Close");
- Mutex mt(myMutex,qApp,MYDELAY);
myStudyFrame->close();
}
+
XYPlot_i::~XYPlot_i() {
if(MYDEBUG) MESSAGE("XYPlot_i::~XYPlot_i");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->close();
}
+
+
void XYPlot_i::SetTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = theTitle;
- myStudyFrame->setCaption(myName.c_str());
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<QAD_StudyFrame,const QString&,QString>
+ (myStudyFrame,&QAD_StudyFrame::setCaption,QString(theTitle)));
}
char* XYPlot_i::GetTitle() {
- if(MYDEBUG) MESSAGE("XYPlot_i::GetTitle");
- Mutex mt(myMutex,qApp);
- myName = (const char*)(myStudyFrame->title());
- return CORBA::string_dup(myName.c_str());
+ return CORBA::string_dup(myStudyFrame->title().latin1());
}
+
void XYPlot_i::SetSubTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetSubTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setTitle(theTitle);
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<Plot2d_ViewFrame,const QString&,QString>
+ (myView,&Plot2d_ViewFrame::setTitle,QString(theTitle)));
}
char* XYPlot_i::GetSubTitle() {
- if(MYDEBUG) MESSAGE("XYPlot_i::GetSubTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
return CORBA::string_dup(myView->getTitle());
}
+
void XYPlot_i::SetCurveType(VISU::XYPlot::CurveType theType){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetCurveType");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setCurveType(theType);
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
+ (myView,&Plot2d_ViewFrame::setCurveType,theType,true));
}
VISU::XYPlot::CurveType XYPlot_i::GetCurveType(){
- if(MYDEBUG) MESSAGE("XYPlot_i::GetCurveType");
- Mutex mt(myMutex,qApp);
return (VISU::XYPlot::CurveType)myView->getCurveType();
}
+
void XYPlot_i::SetMarkerSize(CORBA::Long theSize){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetMarkerSize");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setMarkerSize(theSize);
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
+ (myView,&Plot2d_ViewFrame::setMarkerSize,theSize,true));
}
CORBA::Long XYPlot_i::GetMarkerSize(){
- if(MYDEBUG) MESSAGE("XYPlot_i::GetMarkerSize");
- Mutex mt(myMutex,qApp);
return myView->getMarkerSize();
}
+
+ class TEnbleGridEvent: public SALOME_Event{
+ public:
+ typedef void (Plot2d_ViewFrame::* TFun)(bool, const int, bool, const int, bool = true);
+ TEnbleGridEvent(Plot2d_ViewFrame* theView, TFun theFun,
+ CORBA::Boolean theMajor, CORBA::Long theNumMajor,
+ CORBA::Boolean theMinor, CORBA::Long theNumMinor):
+ myView(theView), myFun(theFun),
+ myMajor(theMajor), myNumMajor(theNumMajor),
+ myMinor(theMinor), myNumMinor(theNumMinor)
+ {}
+ virtual bool Execute(){
+ (myView->*myFun)(myMajor,myNumMajor,myMinor,myNumMinor);
+ return true;
+ }
+ protected:
+ Plot2d_ViewFrame* myView;
+ TFun myFun;
+ CORBA::Boolean myMajor, myNumMajor;
+ CORBA::Boolean myMinor, myNumMinor;
+ };
+
+
void XYPlot_i::EnableXGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor,
- CORBA::Boolean theMinor, CORBA::Long theNumMinor){
- if(MYDEBUG) MESSAGE("XYPlot_i::EnableXGrid");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setXGrid(theMajor,theNumMajor,theMinor,theNumMinor);
+ CORBA::Boolean theMinor, CORBA::Long theNumMinor)
+ {
+ ProcessVoidEvent(new TEnbleGridEvent(myView,&Plot2d_ViewFrame::setXGrid,
+ theMajor,theNumMajor,theMinor,theNumMinor));
}
void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor,
- CORBA::Boolean theMinor, CORBA::Long theNumMinor){
- if(MYDEBUG) MESSAGE("XYPlot_i::EnableYGrid");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setYGrid(theMajor,theNumMajor,theMinor,theNumMinor);
+ CORBA::Boolean theMinor, CORBA::Long theNumMinor)
+ {
+ ProcessVoidEvent(new TEnbleGridEvent(myView,&Plot2d_ViewFrame::setYGrid,
+ theMajor,theNumMajor,theMinor,theNumMinor));
}
+
+ class TSetScaleModeEvent: public SALOME_Event{
+ public:
+ typedef void (Plot2d_ViewFrame::* TFun)(const int, bool = true);
+ TSetScaleModeEvent(Plot2d_ViewFrame* theView, TFun theFun, int theScaling):
+ myView(theView), myFun(theFun), myScaling(theScaling)
+ {}
+ virtual bool Execute(){
+ (myView->*myFun)(myScaling);
+ return true;
+ }
+ protected:
+ Plot2d_ViewFrame* myView;
+ TFun myFun;
+ int myScaling;
+ };
+
+
void XYPlot_i::SetHorScaling(VISU::Scaling theScaling){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetHorScaling");
- Mutex mt(myMutex,qApp,MYDELAY);
- if(theScaling == VISU::LOGARITHMIC)
- myView->setHorScaleMode(1);
- else
- myView->setHorScaleMode(0);
+ ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setHorScaleMode,
+ theScaling == VISU::LOGARITHMIC));
}
VISU::Scaling XYPlot_i::GetHorScaling(){
- if(MYDEBUG) MESSAGE("XYPlot_i::GetHorScaling");
- Mutex mt(myMutex,qApp,MYDELAY);
return (VISU::Scaling)myView->getHorScaleMode();
}
+
void XYPlot_i::SetVerScaling(VISU::Scaling theScaling){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetVerScaling");
- Mutex mt(myMutex,qApp,MYDELAY);
- if(theScaling == VISU::LOGARITHMIC)
- myView->setVerScaleMode(1);
- else
- myView->setVerScaleMode(0);
+ ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setVerScaleMode,
+ theScaling == VISU::LOGARITHMIC));
}
VISU::Scaling XYPlot_i::GetVerScaling(){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetVerScaling");
- Mutex mt(myMutex,qApp);
return (VISU::Scaling)myView->getVerScaleMode();
}
+
+ class TSetTitleEvent: public SALOME_Event{
+ public:
+ typedef void (Plot2d_ViewFrame::* TFun)(bool, const QString&, bool = true);
+ TSetTitleEvent(Plot2d_ViewFrame* theView, TFun theFun, const char* theTitle):
+ myView(theView), myFun(theFun), myTitle(theTitle)
+ {}
+ virtual bool Execute(){
+ (myView->*myFun)(true,myTitle);
+ return true;
+ }
+ protected:
+ Plot2d_ViewFrame* myView;
+ TFun myFun;
+ const char* myTitle;
+ };
+
+
void XYPlot_i::SetXTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetXTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setXTitle(true,theTitle);
+ ProcessVoidEvent(new TSetTitleEvent(myView,&Plot2d_ViewFrame::setXTitle,theTitle));
}
char* XYPlot_i::GetXTitle() {
- if(MYDEBUG) MESSAGE("XYPlot_i::GetXTitle");
- Mutex mt(myMutex,qApp);
return CORBA::string_dup(myView->getXTitle());
}
+
void XYPlot_i::SetYTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetYTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->setYTitle(true,theTitle);
+ ProcessVoidEvent(new TSetTitleEvent(myView,&Plot2d_ViewFrame::setYTitle,theTitle));
}
char* XYPlot_i::GetYTitle() {
- if(MYDEBUG) MESSAGE("XYPlot_i::GetYTitle");
- Mutex mt(myMutex,qApp);
return CORBA::string_dup(myView->getYTitle());
}
+
void XYPlot_i::ShowLegend(CORBA::Boolean theShowing){
- if(MYDEBUG) MESSAGE("XYPlot_i::ShowLegend");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->showLegend(theShowing);
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,bool,bool>
+ (myView,&Plot2d_ViewFrame::showLegend,theShowing,true));
}
+
void XYPlot_i::SetBackground(const SALOMEDS::Color& theColor){
- if(MYDEBUG) MESSAGE("XYPlot_i::SetBackground");
- Mutex mt(myMutex,qApp,MYDELAY);
- int aColor[3];
- aColor[0] = (int)(255.0*theColor.R);
- aColor[1] = (int)(255.0*theColor.G);
- aColor[2] = (int)(255.0*theColor.B);
- QColor aNewColor(aColor[0],aColor[1],aColor[2]);
- myView->setBackgroundColor(aNewColor);
+ ProcessVoidEvent(new TSetBackgroundEvent<Plot2d_ViewFrame>(myView,theColor));
}
SALOMEDS::Color XYPlot_i::GetBackground() {
- if(MYDEBUG) MESSAGE("XYPlot_i::GetBackground");
- Mutex mt(myMutex,qApp);
SALOMEDS::Color aColor;
aColor.R = myView->backgroundColor().red()/255.0;
aColor.G = myView->backgroundColor().green()/255.0;
aColor.B = myView->backgroundColor().blue()/255.0;
return aColor;
}
+
void XYPlot_i::Minimize() {
- if(MYDEBUG) MESSAGE("XYPlot_i::Minimize");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showMinimized();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame,&QAD_StudyFrame::showMinimized));
}
+
void XYPlot_i::Restore() {
- if(MYDEBUG) MESSAGE("XYPlot_i::Restore");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showNormal();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame, &QAD_StudyFrame::showNormal));
}
+
void XYPlot_i::Maximize() {
- if(MYDEBUG) MESSAGE("XYPlot_i::Maximize");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showMaximized();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame, &QAD_StudyFrame::showMaximized));
}
- void XYPlot_i::Display(PrsObject_ptr thePrsObj) {
- if(MYDEBUG) MESSAGE("XYPlot_i::Display");
- Mutex mt(myMutex,qApp,MYDELAY);
- CORBA::Object_ptr anObj = thePrsObj;
- // is it Curve ?
- if(Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(anObj).in())) {
- UpdatePlot2d(myView,eDisplay,aCurve);
- }
- // is it Container ?
- if(Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(anObj).in())) {
- int nbCurves = aContainer->GetNbCurves();
- for ( int i = 1; i <= nbCurves; i++ ) {
- VISU::Curve_i* aCurve = aContainer->GetCurve( i );
- if ( aCurve && aCurve->IsValid() ) {
- UpdatePlot2d(myView,eDisplay,aCurve);
- }
+
+
+ class TXYPlotViewEvent: public SALOME_Event{
+ QAD_Study* myStudy;
+ Plot2d_ViewFrame* myView;
+ PrsObject_ptr myPrsObj;
+ int myDisplaing;
+ public:
+ TXYPlotViewEvent(QAD_Study* theStudy,
+ Plot2d_ViewFrame* theView,
+ PrsObject_ptr thePrsObj,
+ int theDisplaing):
+ myStudy(theStudy),
+ myView(theView),
+ myPrsObj(thePrsObj),
+ myDisplaing(theDisplaing)
+ {}
+ virtual bool Execute(){
+ // is it Curve ?
+ if(Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(myPrsObj).in())) {
+ UpdatePlot2d(myView,myDisplaing,aCurve);
}
- myView->Repaint();
- }
- // is it Table ?
- if(Table_i* aTable = dynamic_cast<Table_i*>(VISU::GetServant(anObj).in())) {
- SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() );
- if ( !TableSO->_is_nil() ) {
- SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO );
- for ( ; Iter->More(); Iter->Next() ) {
- CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() );
- if( !CORBA::is_nil( childObject ) ) {
- CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject );
- if( !CORBA::is_nil( aCurve ) )
- UpdatePlot2d(myView,eDisplay,dynamic_cast<VISU::Curve_i*>( VISU::GetServant(aCurve).in()));
+ // is it Container ?
+ if(Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(myPrsObj).in())) {
+ int nbCurves = aContainer->GetNbCurves();
+ for ( int i = 1; i <= nbCurves; i++ ) {
+ VISU::Curve_i* aCurve = aContainer->GetCurve( i );
+ if ( aCurve && aCurve->IsValid() ) {
+ UpdatePlot2d(myView,myDisplaing,aCurve);
}
}
myView->Repaint();
}
- }
- }
- void XYPlot_i::Erase(PrsObject_ptr thePrsObj) {
- if(MYDEBUG) MESSAGE("XYPlot_i::Erase");
- Mutex mt(myMutex,qApp,MYDELAY);
- CORBA::Object_ptr anObj = thePrsObj;
- // is it Curve ?
- if(Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(anObj).in())) {
- UpdatePlot2d(myView,eErase,aCurve);
- }
- // is it Container ?
- if(Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(anObj).in())) {
- int nbCurves = aContainer->GetNbCurves();
- for ( int i = 1; i <= nbCurves; i++ ) {
- VISU::Curve_i* aCurve = aContainer->GetCurve( i );
- if ( aCurve && aCurve->IsValid() ) {
- UpdatePlot2d(myView,eErase,aCurve);
- }
- }
- myView->Repaint();
- }
- // is it Table ?
- if(Table_i* aTable = dynamic_cast<Table_i*>(VISU::GetServant(anObj).in())) {
- SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() );
- if ( !TableSO->_is_nil() ) {
- SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO );
+ // is it Table ?
+ if(Table_i* aTable = dynamic_cast<Table_i*>(VISU::GetServant(myPrsObj).in())) {
+ SALOMEDS::Study_var aStudy = myStudy->getStudyDocument();
+ SALOMEDS::SObject_var TableSO = aStudy->FindObjectID( aTable->GetEntry() );
+ if ( !TableSO->_is_nil() ) {
+ SALOMEDS::ChildIterator_var Iter = aStudy->NewChildIterator( TableSO );
for ( ; Iter->More(); Iter->Next() ) {
- CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() );
- if( !CORBA::is_nil( childObject ) ) {
- CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject );
- if( !CORBA::is_nil( aCurve ) )
- UpdatePlot2d(myView,eErase,dynamic_cast<VISU::Curve_i*>( VISU::GetServant(aCurve).in()));
+ CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() );
+ if( !CORBA::is_nil( childObject ) ) {
+ CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject );
+ if( !CORBA::is_nil( aCurve ) )
+ UpdatePlot2d(myView,myDisplaing,dynamic_cast<VISU::Curve_i*>( VISU::GetServant(aCurve).in()));
+ }
}
+ myView->Repaint();
}
- myView->Repaint();
}
+ return true;
}
+ };
+
+
+ void XYPlot_i::Display(PrsObject_ptr thePrsObj) {
+ ProcessVoidEvent(new TXYPlotViewEvent(myStudy,myView,thePrsObj,eDisplay));
}
- void XYPlot_i::EraseAll() {
- if(MYDEBUG) MESSAGE("XYPlot_i::EraseAll");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->EraseAll();
+
+
+ void XYPlot_i::Erase(PrsObject_ptr thePrsObj) {
+ ProcessVoidEvent(new TXYPlotViewEvent(myStudy,myView,thePrsObj,eErase));
}
+
+
void XYPlot_i::DisplayOnly(PrsObject_ptr thePrsObj) {
- if(MYDEBUG) MESSAGE("XYPlot_i::DisplayOnly");
- Mutex mt(myMutex,qApp,MYDELAY);
- CORBA::Object_ptr anObj = thePrsObj;
- // is it Curve ?
- if(Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(anObj).in())) {
- UpdatePlot2d(myView,eDisplayOnly,aCurve);
- }
- // is it Container ?
- if(Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(anObj).in())) {
- int nbCurves = aContainer->GetNbCurves();
- for ( int i = 1; i <= nbCurves; i++ ) {
- VISU::Curve_i* aCurve = aContainer->GetCurve( i );
- if ( aCurve && aCurve->IsValid() ) {
- UpdatePlot2d(myView,eDisplayOnly,aCurve);
- }
- }
- myView->Repaint();
- }
- // is it Table ?
- if(Table_i* aTable = dynamic_cast<Table_i*>(VISU::GetServant(anObj).in())) {
- SALOMEDS::SObject_var TableSO = myStudy->getStudyDocument()->FindObjectID( aTable->GetEntry() );
- if ( !TableSO->_is_nil() ) {
- SALOMEDS::ChildIterator_var Iter = myStudy->getStudyDocument()->NewChildIterator( TableSO );
- for ( ; Iter->More(); Iter->Next() ) {
- CORBA::Object_var childObject = VISU::SObjectToObject( Iter->Value() );
- if( !CORBA::is_nil( childObject ) ) {
- CORBA::Object_ptr aCurve = VISU::Curve::_narrow( childObject );
- if( !CORBA::is_nil( aCurve ) )
- UpdatePlot2d(myView,eDisplayOnly,dynamic_cast<VISU::Curve_i*>( VISU::GetServant(aCurve).in()));
- }
- }
- myView->Repaint();
- }
- }
+ ProcessVoidEvent(new TXYPlotViewEvent(myStudy,myView,thePrsObj,eDisplayOnly));
+ }
+
+
+ void XYPlot_i::EraseAll() {
+ ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::EraseAll));
}
+
+
void XYPlot_i::FitAll() {
- if(MYDEBUG) MESSAGE("XYPlot_i::FitAll");
- Mutex mt(myMutex,qApp,MYDELAY);
- myView->fitAll();
+ ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::fitAll));
}
+
+
CORBA::Boolean XYPlot_i::SavePicture(const char* theFileName) {
- if(MYDEBUG) MESSAGE("XYPlot_i::SavePicture");
- Mutex mt(myMutex,qApp,MYDELAY);
- if (!myView->getViewWidget())
- return false;
-
- QApplication::setOverrideCursor( Qt::waitCursor );
- QPixmap px = QPixmap::grabWindow(myView->getViewWidget()->winId());
- QApplication::restoreOverrideCursor();
-
- if (!QString(theFileName).isNull()) {
- QApplication::setOverrideCursor( Qt::waitCursor );
- QString fmt = QAD_Tools::getFileExtensionFromPath(theFileName).upper();
- if (fmt.isEmpty())
- fmt = QString("BMP"); // default format
- if (fmt == "JPG")
- fmt = "JPEG";
- bool bOk = px.save(theFileName, fmt.latin1());
- QApplication::restoreOverrideCursor();
- return bOk;
- }
- return false;
+ TSavePictureEvent* ve = new TSavePictureEvent(myView->getViewWidget(),theFileName);
+ ve->process();
+ TSavePictureEvent::TResult aResult = ve->myResult;
+ ve->release();
+ return aResult;
}
+
//===========================================================================
TableView_i::TableView_i(SALOMEDS::Study_ptr theStudy) : View_i(theStudy) {}
- Storable* TableView_i::Create(VISU::Table_var theTable){
+ Storable* TableView_i::Create(VISU::Table_ptr theTable){
if(MYDEBUG) MESSAGE("TableView_i::Create - "<<(!theTable->_is_nil()));
- Mutex mt(myMutex,qApp,MYDELAY);
if(!theTable->_is_nil()){
- VISU::Table_i* table = dynamic_cast<VISU::Table_i*>(VISU::GetServant(theTable.in()).in());
+ VISU::Table_i* table = dynamic_cast<VISU::Table_i*>(VISU::GetServant(theTable).in());
if(MYDEBUG) MESSAGE("TableView_i::Create - dynamic_cast = "<<table);
if(table != NULL) {
SALOMEDS::SObject_var aSObject = myStudy->getStudyDocument()->FindObjectID(table->GetObjectEntry());
SALOMEGUI_TableDlg::ttAuto,
Qt::Vertical);
myView->show();
- myName = (myView->caption()).latin1();
return this;
}
}
}
return NULL;
}
+
+
+ TableView_i::~TableView_i() {
+ if(MYDEBUG) MESSAGE("TableView_i::~TableView_i");
+ delete myView;
+ }
+
+
void TableView_i::SetTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("TableView_i::SetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = theTitle;
- myView->setCaption(myName.c_str());
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<SALOMEGUI_TableDlg,const QString&,QString>
+ (myView,&SALOMEGUI_TableDlg::setCaption,QString(theTitle)));
}
+
+
char* TableView_i::GetTitle() {
- if(MYDEBUG) MESSAGE("TableView_i::GetTitle");
- Mutex mt(myMutex,qApp);
- myName = (myView->caption()).latin1();
- return CORBA::string_dup(myName.c_str());
+ return CORBA::string_dup(myView->caption().latin1());
}
+
+
void TableView_i::Close(){
- if(MYDEBUG) MESSAGE("TableView_i::Close");
- Mutex mt(myMutex,qApp,MYDELAY);
myView->close();
}
- TableView_i::~TableView_i() {
- if(MYDEBUG) MESSAGE("TableView_i::~TableView_i");
- Mutex mt(myMutex,qApp,MYDELAY);
- Close();
- delete myView;
- }
+
+
//===========================================================================
int View3D_i::myNbViewParams = 0;
const string View3D_i::myComment = "VIEW3D";
myStudyFrame = myStudy->newWindow3d("",VIEW_VTK);
else
myStudyFrame = myStudy->getActiveStudyFrame();
+ return this;
+ }
- //GetViewFrame(myStudyFrame)->GetScale(myScaleFactor);
-
- return this; //Build(false);
- }
-
-// Storable* View3D_i::Build(int theRestoring){
-// if(MYDEBUG) MESSAGE("View3D_i::Build");
-// if(theRestoring){
-// myStudyFrame->setTitle(myName.c_str());
-// SetBackground(myColor);
-// SetPointOfView(myPosition);
-// SetViewUp(myViewUp);
-// SetFocalPoint(myFocalPnt);
-// SetParallelScale(myParallelScale);
-// ScaleView(VISU::View3D::XAxis,myScaleFactor[0]);
-// ScaleView(VISU::View3D::YAxis,myScaleFactor[1]);
-// ScaleView(VISU::View3D::ZAxis,myScaleFactor[2]);
-// RepaintView(myStudyFrame);
-// }else{
-// Update();
-
-// SALOMEDS::SComponent_var aSComponent = FindOrCreateVisuComponent(myStudyDocument);
-// CORBA::String_var aSComponentEntry = aSComponent->GetID(), anIOR(GetID());
-// string anEntry = CreateAttributes(myStudyDocument,aSComponentEntry,"",anIOR,myName.c_str(),"",GetComment());
-
-// }
-// return this;
-// }
void View3D_i::Update(){
- if(MYDEBUG) MESSAGE("View3D_i::Update");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = (const char*)myStudyFrame->title();
-// myColor = GetBackground();
-// GetCamera(myStudyFrame)->GetPosition(myPosition);
-// GetCamera(myStudyFrame)->GetViewUp(myViewUp);
-// GetCamera(myStudyFrame)->GetFocalPoint(myFocalPnt);
-// myParallelScale = GetCamera(myStudyFrame)->GetParallelScale();
- //RepaintView(myStudyFrame);
-
- //GetViewFrame(myStudyFrame)->GetScale(myScaleFactor);
-
- VTKViewer_ViewFrame* vf = GetViewFrame(myStudyFrame);
- vtkRenderer* Renderer = vf->getRenderer();
- vtkActorCollection* theActors = Renderer->GetActors();
- theActors->InitTraversal();
- vtkActor *actor;
- while(actor = theActors->GetNextActor()){
- if(VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(actor)){
- VISU::Prs3d_i* aPrs3d = anActor->GetPrs3d();
- if(anActor->GetVisibility() && aPrs3d){
- aPrs3d->Update();
- aPrs3d->UpdateActor(anActor);
+ class TEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ public:
+ TEvent(QAD_StudyFrame* theStudyFrame):
+ myStudyFrame(theStudyFrame)
+ {}
+ virtual bool Execute(){
+ VTKViewer_ViewFrame* vf = GetViewFrame(myStudyFrame);
+ vtkRenderer* Renderer = vf->getRenderer();
+ vtkActorCollection* theActors = Renderer->GetActors();
+ theActors->InitTraversal();
+ vtkActor *actor;
+ while(actor = theActors->GetNextActor()){
+ if(VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(actor)){
+ VISU::Prs3d_i* aPrs3d = anActor->GetPrs3d();
+ if(anActor->GetVisibility() && aPrs3d){
+ aPrs3d->Update();
+ aPrs3d->UpdateActor(anActor);
+ }
+ }
}
+ return true;
}
- }
+ };
+ ProcessVoidEvent(new TEvent(myStudyFrame));
}
+
CORBA::Boolean View3D_i::SavePicture(const char* theFileName) {
- if(MYDEBUG) MESSAGE("View3D_i::SavePicture");
- Mutex mt(myMutex,qApp,MYDELAY);
- if (!myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget())
- return false;
-
- QApplication::setOverrideCursor( Qt::waitCursor );
- QPixmap px = QPixmap::grabWindow(myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget()->winId());
- QApplication::restoreOverrideCursor();
-
- if (!QString(theFileName).isNull()) {
- QApplication::setOverrideCursor( Qt::waitCursor );
- QString fmt = QAD_Tools::getFileExtensionFromPath(theFileName).upper();
- if (fmt.isEmpty())
- fmt = QString("BMP"); // default format
- if (fmt == "JPG")
- fmt = "JPEG";
- bool bOk = px.save(theFileName, fmt.latin1());
- QApplication::restoreOverrideCursor();
- return bOk;
- }
- return false;
+ TSavePictureEvent* ve = new TSavePictureEvent(myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget(),theFileName);
+ ve->process();
+ TSavePictureEvent::TResult aResult = ve->myResult;
+ ve->release();
+ return aResult;
}
- CORBA::Boolean View3D_i::SaveViewParams(const char* theName){
- if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint");
- Mutex mt(myMutex,qApp,MYDELAY);
+
+ bool View3D_i::SaveViewParams(QAD_StudyFrame* theStudyFrame, const char* theName){
+ QAD_Study* aStudy = theStudyFrame->getStudy();
+ SALOMEDS::Study_var aStudyDoc = aStudy->getStudyDocument();
if ( theName ) {
SALOMEDS::Study::ListOfSObject_var aList =
- myStudy->getStudyDocument()->FindObjectByName(theName,"VISU");
+ aStudyDoc->FindObjectByName(theName,"VISU");
SALOMEDS::GenericAttribute_var anAttr;
int iEnd = aList->length();
for(int i = 0; i < iEnd; i++){
SALOMEDS::SObject_var anObj = aList[i];
CORBA::String_var aString = anObj->GetID();
string anEntry(aString);
- if(MYDEBUG) MESSAGE("View3D_i::SaveViewP
oint - anEntry = "<<anEntry);
+ if(MYDEBUG) MESSAGE("View3D_i::SaveViewP
arams - anEntry = "<<anEntry);
if(anObj->FindAttribute(anAttr, "AttributeComment")){
SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
aString = aCmnt->Value();
string aComm(aString);
if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint - aComm = "<<aComm);
if(aComm.compare(View3D_i::myComment) >= 0){
- aCmnt->SetValue(ToString().c_str());
- return 1;
+ aCmnt->SetValue(ToString(theStudyFrame).c_str());
+ return true;
}
}
}
}
- QString newName;
- if ( theName )
- newName = QString( theName );
- else
- newName = QString( GenerateViewParamsName() );
- SALOMEDS::SComponent_var aSComponent =
- FindOrCreateVisuComponent(myStudy->getStudyDocument());
- CORBA::String_var aSComponentEntry = aSComponent->GetID(), anIOR(GetID());
- string anEntry = CreateAttributes(myStudy->getStudyDocument(),aSComponentEntry,"","",newName.latin1(),"",ToString().c_str());
- return 1;
+ SALOMEDS::SComponent_var aSComponent = FindOrCreateVisuComponent(aStudyDoc);
+ CORBA::String_var aSComponentEntry = aSComponent->GetID();
+ string anEntry = CreateAttributes(aStudyDoc,aSComponentEntry.in(),"","",theName,"",ToString(theStudyFrame).c_str());
+ return true;
+ }
+ CORBA::Boolean View3D_i::SaveViewParams(const char* theName){
+ return SaveViewParams(myStudyFrame,theName);
}
- CORBA::Boolean View3D_i::RestoreViewParams(const char* theName){
- if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - "<<theName);
- Mutex mt(myMutex,qApp,MYDELAY);
+
+ bool View3D_i::RestoreViewParams(QAD_StudyFrame* theStudyFrame, const char* theName){
SALOMEDS::Study::ListOfSObject_var aList =
- myStudy->getStudyDocument()->FindObjectByName(theName,"VISU");
+ theStudyFrame->getStudy()->getStudyDocument()->FindObjectByName(theName,"VISU");
SALOMEDS::GenericAttribute_var anAttr;
int iEnd = aList->length();
if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - iEnd = "<<iEnd);
Storable::StrToMap(strIn,aMap);
if ( Storable::FindValue( aMap,"myComment").compare( View3D_i::myComment.c_str() ) >= 0 ) {
if(MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - aComm = "<<strIn);
- return Restore( aMap ) != NULL;
+ Restore(theStudyFrame,aMap);
+ return true;
}
}
}
- return 0;
+ return false;
}
- Storable* View3D_i::Restore(const Storable::TRestoringMap& theMap) {
- // if(MYDEBUG) MESSAGE("View3D_i::Restore");
- //myName = VISU::Storable::FindValue(theMap,"myName").latin1();
-
+
+ CORBA::Boolean View3D_i::RestoreViewParams(const char* theName){
+ class TEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ const char* myName;
+ public:
+ TEvent(QAD_StudyFrame* theStudyFrame,
+ const char* theName):
+ myStudyFrame(theStudyFrame),
+ myName(theName)
+ {}
+ virtual bool Execute(){
+ myResult = RestoreViewParams(myStudyFrame,myName);
+ return true;
+ }
+ typedef CORBA::Boolean TResult;
+ TResult myResult;
+ };
+ TEvent* ve = new TEvent(myStudyFrame,theName);
+ ve->process();
+ TEvent::TResult aResult = ve->myResult;
+ ve->release();
+ return aResult;
+ }
+
+
+ void View3D_i::Restore(QAD_StudyFrame* theStudyFrame, const Storable::TRestoringMap& theMap) throw(std::logic_error&){
SALOMEDS::Color aColor;
aColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
aColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
aScaleFactor[1] = VISU::Storable::FindValue(theMap,"myScaleFactor[1]").toDouble();
aScaleFactor[2] = VISU::Storable::FindValue(theMap,"myScaleFactor[2]").toDouble();
- //myStudyFrame->setTitle(myName.c_str());
- SetBackground(aColor);
- SetPointOfView(aPosition);
- SetViewUp(aViewUp);
- SetFocalPoint(aFocalPnt);
- SetParallelScale(aParallelScale);
- ScaleView(VISU::View3D::XAxis,aScaleFactor[0]);
- ScaleView(VISU::View3D::YAxis,aScaleFactor[1]);
- ScaleView(VISU::View3D::ZAxis,aScaleFactor[2]);
- RepaintView(myStudyFrame);
+ SetBackground(theStudyFrame,aColor);
+ SetPointOfView(theStudyFrame,aPosition);
+ SetViewUp(theStudyFrame,aViewUp);
+ SetFocalPoint(theStudyFrame,aFocalPnt);
+ SetParallelScale(theStudyFrame,aParallelScale);
+ ScaleView(theStudyFrame,VISU::View3D::XAxis,aScaleFactor[0]);
+ ScaleView(theStudyFrame,VISU::View3D::YAxis,aScaleFactor[1]);
+ ScaleView(theStudyFrame,VISU::View3D::ZAxis,aScaleFactor[2]);
+ }
+ Storable* View3D_i::Restore(const Storable::TRestoringMap& theMap) throw(std::logic_error&) {
+ Restore(myStudyFrame,theMap);
return this;
}
- void View3D_i::ToStream(std::ostringstream& theStr) {
+ string View3D_i::ToString(QAD_StudyFrame* theStudyFrame){
+ ostringstream strOut;
+ Storable::DataToStream( strOut, "myComment", myComment.c_str() );
+ ToStream(theStudyFrame,strOut);
+ strOut<<ends;
+ if(MYDEBUG) MESSAGE("View3D_i::ToString - "<<strOut.str());
+ return strOut.str();
+ }
+ void View3D_i::ToStream(QAD_StudyFrame* theStudyFrame, std::ostringstream& theStr) {
Storable::DataToStream(theStr,"myType",VISU::TVIEW3D);
float backint[3];
- GetRenderer(myStudyFrame)->GetBackground(backint);
+ GetRenderer(theStudyFrame)->GetBackground(backint);
Storable::DataToStream(theStr,"myColor.R",backint[0]);
Storable::DataToStream(theStr,"myColor.G",backint[1]);
Storable::DataToStream(theStr,"myColor.B",backint[2]);
double aPosition[3];
- GetPointOfView(myStudyFrame,aPosition);
+ GetPointOfView(theStudyFrame,aPosition);
Storable::DataToStream(theStr,"myPosition[0]",aPosition[0]);
Storable::DataToStream(theStr,"myPosition[1]",aPosition[1]);
Storable::DataToStream(theStr,"myPosition[2]",aPosition[2]);
double aFocalPnt[3];
- GetFocalPoint(myStudyFrame,aFocalPnt);
+ GetFocalPoint(theStudyFrame,aFocalPnt);
Storable::DataToStream(theStr,"myFocalPnt[0]",aFocalPnt[0]);
Storable::DataToStream(theStr,"myFocalPnt[1]",aFocalPnt[1]);
Storable::DataToStream(theStr,"myFocalPnt[2]",aFocalPnt[2]);
double aViewUp[3];
- GetCamera(myStudyFrame)->GetViewUp(aViewUp);
+ GetCamera(theStudyFrame)->GetViewUp(aViewUp);
Storable::DataToStream(theStr,"myViewUp[0]",aViewUp[0]);
Storable::DataToStream(theStr,"myViewUp[1]",aViewUp[1]);
Storable::DataToStream(theStr,"myViewUp[2]",aViewUp[2]);
- Storable::DataToStream(theStr,"myParallelScale",GetParallelScale(myStudyFrame));
+ Storable::DataToStream(theStr,"myParallelScale",GetParallelScale(theStudyFrame));
double aScaleFactor[3];
- GetViewFrame(myStudyFrame)->GetScale(aScaleFactor);
+ GetViewFrame(theStudyFrame)->GetScale(aScaleFactor);
Storable::DataToStream(theStr,"myScaleFactor[0]",aScaleFactor[0]);
Storable::DataToStream(theStr,"myScaleFactor[1]",aScaleFactor[1]);
Storable::DataToStream(theStr,"myScaleFactor[2]",aScaleFactor[2]);
}
+ void View3D_i::ToStream(std::ostringstream& theStr) {
+ ToStream(myStudyFrame,theStr);
+ }
-// Storable* VISU::View3DRestore(SALOMEDS::SComponent_var& theSComponent, SALOMEDS::Study_var& theStudy,
-// const char* thePrefix, const Storable::TRestoringMap& theMap)
-// {
-// try{
-// View3D_i* pView3D = new View3D_i(theStudy);
-// return pView3D->Restore(theMap);
-// }catch(std::logic_error& exc){
-// MESSAGE("Follow exception was accured :\n"<<exc.what());
-// }catch(...){
-// MESSAGE("Unknown exception was accured!");
-// }
-// return NULL;
-// }
-
void View3D_i::Close(){
- if(MYDEBUG) MESSAGE("View3D_i::Close");
- Mutex mt(myMutex,qApp,MYDELAY);
myStudyFrame->close();
}
View3D_i::~View3D_i() {
if(MYDEBUG) MESSAGE("View3D_i::~View3D_i");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->close();
}
//-------------------- View interface --------------------
void View3D_i::SetTitle(const char* theTitle){
- if(MYDEBUG) MESSAGE("View3D_i::SetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = theTitle;
- myStudyFrame->setTitle(myName.c_str());
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<QAD_StudyFrame,const QString&,QString>
+ (myStudyFrame,&QAD_StudyFrame::setTitle,QString(theTitle)));
}
char* View3D_i::GetTitle() {
- if(MYDEBUG) MESSAGE("View3D_i::GetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = (const char*)myStudyFrame->title();
- return CORBA::string_dup(myName.c_str());
+ return CORBA::string_dup(myStudyFrame->title().latin1());
}
+
void View3D_i::SetBackground(QAD_StudyFrame* theStudyFrame, const SALOMEDS::Color& theColor) {
int aColor[3];
- aColor[0] = (int)(255.0*theColor.R);
- aColor[1] = (int)(255.0*theColor.G);
- aColor[2] = (int)(255.0*theColor.B);
+ aColor[0] = int(255.0*theColor.R);
+ aColor[1] = int(255.0*theColor.G);
+ aColor[2] = int(255.0*theColor.B);
QColor aNewColor(aColor[0],aColor[1],aColor[2]);
GetViewFrame(theStudyFrame)->setBackgroundColor(aNewColor);
}
void View3D_i::SetBackground(const SALOMEDS::Color& theColor) {
- if(MYDEBUG) MESSAGE("View3D_i::SetBackground");
- Mutex mt(myMutex,qApp,MYDELAY);
- //myColor.R = theColor.R; myColor.G = theColor.G; myColor.B = theColor.B;
- SetBackground(myStudyFrame,theColor);
+ ProcessVoidEvent(new TSetBackgroundEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),theColor));
}
+
SALOMEDS::Color View3D_i::GetBackground(QAD_StudyFrame* theStudyFrame) {
SALOMEDS::Color aColor;
float backint[3];
return aColor;
}
SALOMEDS::Color View3D_i::GetBackground() {
- if(MYDEBUG) MESSAGE("View3D_i::GetBackground");
- Mutex mt(myMutex,qApp,MYDELAY);
- //myColor = GetBackground(myStudyFrame);
- return GetBackground(myStudyFrame); //myColor;
+ return GetBackground(myStudyFrame);
}
+
void View3D_i::Minimize() {
- if(MYDEBUG) MESSAGE("View3D_i::Minimize");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showMinimized();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame,&QAD_StudyFrame::showMinimized));
}
void View3D_i::Restore() {
- if(MYDEBUG) MESSAGE("View3D_i::Restore");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showNormal();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame, &QAD_StudyFrame::showNormal));
}
void View3D_i::Maximize() {
- if(MYDEBUG) MESSAGE("View3D_i::Maximize");
- Mutex mt(myMutex,qApp,MYDELAY);
- myStudyFrame->showMaximized();
+ ProcessVoidEvent(new TFrameActionEvent(myStudyFrame, &QAD_StudyFrame::showMaximized));
}
+
+
//===========================================================================
+ class TUpdateViewerEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ Prs3d_i* myPrs3d;
+ int myDisplaing;
+ public:
+ TUpdateViewerEvent(QAD_StudyFrame* theStudyFrame,
+ Prs3d_i* thePrs3d,
+ int theDisplaing):
+ myStudyFrame(theStudyFrame),
+ myPrs3d(thePrs3d),
+ myDisplaing(theDisplaing)
+ {}
+ virtual bool Execute(){
+ UpdateViewer(myStudyFrame,myDisplaing,myPrs3d);
+ return true;
+ }
+ };
+
void View3D_i::EraseAll() {
if(MYDEBUG) MESSAGE("View3D_i::EraseAll");
- Mutex mt(myMutex,qApp,MYDELAY);
- UpdateViewer(myStudyFrame,eEraseAll);
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,NULL,eEraseAll));
}
+
void View3D_i::DisplayAll() {
if(MYDEBUG) MESSAGE("View3D_i::DisplayAll");
- Mutex mt(myMutex,qApp,MYDELAY);
- UpdateViewer(myStudyFrame,eDisplayAll);
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,NULL,eDisplayAll));
}
+
void View3D_i::Erase(PrsObject_ptr thePrsObj) {
if(MYDEBUG) MESSAGE("View3D_i::Erase");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in()))
- UpdateViewer(myStudyFrame,eErase,aPrs);
+ if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eErase));
+ }
}
+
void View3D_i::Display(PrsObject_ptr thePrsObj) {
if(MYDEBUG) MESSAGE("View3D_i::Display");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in()))
- UpdateViewer(myStudyFrame,eDisplay,aPrs);
+ if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eDisplay));
+ }
}
+
void View3D_i::DisplayOnly(PrsObject_ptr thePrsObj) {
if(MYDEBUG) MESSAGE("View3D_i::DisplayOnly");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in()))
- UpdateViewer(myStudyFrame,eDisplayOnly,aPrs);
+ if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eDisplayOnly));
+ }
}
//-------------------- View3D interface --------------------
void View3D_i::FitAll() {
- if(MYDEBUG) MESSAGE("View3D_i::FitAll");
- Mutex mt(myMutex,qApp,MYDELAY);
- GetViewFrame(myStudyFrame)->onViewFitAll();
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewFitAll));
Update();
}
+
+
void View3D_i::SetView(VISU::View3D::ViewType theType) {
- if(MYDEBUG) MESSAGE("View3D_i::SetView");
- Mutex mt(myMutex,qApp,MYDELAY);
switch(theType){
- case VISU::View3D::FRONT : GetViewFrame(myStudyFrame)->onViewFront(); break;
- case VISU::View3D::BACK : GetViewFrame(myStudyFrame)->onViewBack(); break;
- case VISU::View3D::LEFT : GetViewFrame(myStudyFrame)->onViewLeft(); break;
- case VISU::View3D::RIGHT : GetViewFrame(myStudyFrame)->onViewRight(); break;
- case VISU::View3D::TOP : GetViewFrame(myStudyFrame)->onViewTop(); break;
- case VISU::View3D::BOTTOM : GetViewFrame(myStudyFrame)->onViewBottom(); break;
+ case VISU::View3D::FRONT :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewFront));
+ break;
+ case VISU::View3D::BACK :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewBack));
+ break;
+ case VISU::View3D::LEFT :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewLeft));
+ break;
+ case VISU::View3D::RIGHT :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewRight));
+ break;
+ case VISU::View3D::TOP :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewTop));
+ break;
+ case VISU::View3D::BOTTOM :
+ ProcessVoidEvent(new TVoidMemFunEvent<VTKViewer_ViewFrame>(GetViewFrame(myStudyFrame),&VTKViewer_ViewFrame::onViewBottom));
+ break;
}
Update();
}
+
+ class TSet3DViewParamEvent: public SALOME_Event{
+ public:
+ typedef void (*TFun)(QAD_StudyFrame* theStudyFrame, const CORBA::Double theParam[3]);
+ TSet3DViewParamEvent(TFun theFun,
+ QAD_StudyFrame* theStudyFrame,
+ const CORBA::Double theParam[3]):
+ myFun(theFun),
+ myStudyFrame(theStudyFrame),
+ myParam(theParam)
+ {}
+ virtual bool Execute(){
+ myFun(myStudyFrame,myParam);
+ return true;
+ }
+ private:
+ TFun myFun;
+ QAD_StudyFrame* myStudyFrame;
+ const CORBA::Double* myParam;
+ };
+
+
void View3D_i::SetPointOfView(QAD_StudyFrame* theStudyFrame, const CORBA::Double thePosition[3]) {
GetCamera(theStudyFrame)->SetPosition(thePosition);
}
- void View3D_i::SetPointOfView(const VISU::View3D::XYZ theCoord) {
+ void View3D_i::SetPointOfView(const VISU::View3D::XYZ thePosition) {
if(MYDEBUG) MESSAGE("View3D_i::SetPointOfView");
- Mutex mt(myMutex,qApp,MYDELAY);
- //VISU::View3D::XYZ_copy(myPosition,theCoord);
- SetPointOfView(myStudyFrame, theCoord);
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetPointOfView,myStudyFrame,thePosition));
}
+
void View3D_i::GetPointOfView(QAD_StudyFrame* theStudyFrame, CORBA::Double thePosition[3]) {
GetCamera(theStudyFrame)->GetPosition(thePosition);
}
VISU::View3D::XYZ_slice* View3D_i::GetPointOfView() {
if(MYDEBUG) MESSAGE("View3D_i::GetPointOfView");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Double aPosition[3];
GetPointOfView(myStudyFrame,aPosition);
return VISU::View3D::XYZ_dup(aPosition);
}
+
void View3D_i::SetViewUp(QAD_StudyFrame* theStudyFrame, const CORBA::Double theViewUp[3]) {
GetCamera(theStudyFrame)->SetViewUp(theViewUp);
}
- void View3D_i::SetViewUp(const VISU::View3D::XYZ theDir) {
+ void View3D_i::SetViewUp(const VISU::View3D::XYZ theViewUp) {
if(MYDEBUG) MESSAGE("View3D_i::SetViewUp");
- Mutex mt(myMutex,qApp,MYDELAY);
- //VISU::View3D::XYZ_copy(myViewUp,theDir);
- SetViewUp(myStudyFrame, theDir);
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetViewUp,myStudyFrame,theViewUp));
}
+
void View3D_i::GetViewUp(QAD_StudyFrame* theStudyFrame, CORBA::Double theViewUp[3]) {
GetCamera(theStudyFrame)->GetViewUp(theViewUp);
}
VISU::View3D::XYZ_slice* View3D_i::GetViewUp() {
if(MYDEBUG) MESSAGE("View3D_i::GetViewUp");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Double aViewUp[3];
GetCamera(myStudyFrame)->GetViewUp(aViewUp);
return VISU::View3D::XYZ_dup(aViewUp);
}
+
void View3D_i::SetFocalPoint(QAD_StudyFrame* theStudyFrame, const CORBA::Double theFocalPnt[3]) {
GetCamera(theStudyFrame)->SetFocalPoint(theFocalPnt);
}
void View3D_i::SetFocalPoint(const VISU::View3D::XYZ theCoord) {
if(MYDEBUG) MESSAGE("View3D_i::SetFocalPoint");
- Mutex mt(myMutex,qApp,MYDELAY);
- //VISU::View3D::XYZ_copy(myFocalPnt,theCoord);
- SetFocalPoint(myStudyFrame,theCoord);
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetFocalPoint,myStudyFrame,theCoord));
}
+
void View3D_i::GetFocalPoint(QAD_StudyFrame* theStudyFrame, CORBA::Double theFocalPnt[3]) {
GetCamera(theStudyFrame)->GetFocalPoint(theFocalPnt);
}
VISU::View3D::XYZ_slice* View3D_i::GetFocalPoint() {
if(MYDEBUG) MESSAGE("View3D_i::GetFocalPoint");
- Mutex mt(myMutex,qApp,MYDELAY);
CORBA::Double aFocalPnt[3];
GetFocalPoint(myStudyFrame,aFocalPnt);
return VISU::View3D::XYZ_dup(aFocalPnt);
}
+
+ class TSetViewParamEvent: public SALOME_Event{
+ public:
+ typedef void (*TFun)(QAD_StudyFrame* theStudyFrame, CORBA::Double theParam);
+ TSetViewParamEvent(TFun theFun,
+ QAD_StudyFrame* theStudyFrame,
+ CORBA::Double theParam):
+ myFun(theFun),
+ myStudyFrame(theStudyFrame),
+ myParam(theParam)
+ {}
+ virtual bool Execute(){
+ myFun(myStudyFrame,myParam);
+ return true;
+ }
+ private:
+ TFun myFun;
+ QAD_StudyFrame* myStudyFrame;
+ CORBA::Double myParam;
+ };
+
+
void View3D_i::SetParallelScale(QAD_StudyFrame* theStudyFrame, CORBA::Double theScale) {
GetCamera(theStudyFrame)->SetParallelScale(theScale);
}
void View3D_i::SetParallelScale(CORBA::Double theScale) {
if(MYDEBUG) MESSAGE("View3D_i::SetParallelScale");
- Mutex mt(myMutex,qApp,MYDELAY);
- //myParallelScale = theScale;
- SetParallelScale(myStudyFrame, theScale);
+ ProcessVoidEvent(new TSetViewParamEvent(&SetParallelScale,myStudyFrame,theScale));
}
+
CORBA::Double View3D_i::GetParallelScale(QAD_StudyFrame* theStudyFrame) {
return GetCamera(theStudyFrame)->GetParallelScale();
}
CORBA::Double View3D_i::GetParallelScale() {
if(MYDEBUG) MESSAGE("View3D_i::GetParallelScale");
- Mutex mt(myMutex,qApp);
return GetParallelScale(myStudyFrame);
}
aScaleFactor[theAxis] = theParam;
aViewFrame->SetScale(aScaleFactor);
}
+
+ void SetScaleView(QAD_StudyFrame* theStudyFrame, const CORBA::Double theScale[3]){
+ double aScale[3] = {theScale[0], theScale[1], theScale[2]};
+ GetViewFrame(theStudyFrame)->SetScale(aScale);
+ }
void View3D_i::ScaleView(VISU::View3D::Axis theAxis, CORBA::Double theParam) {
if(MYDEBUG) MESSAGE("View3D_i::ScaleView");
- Mutex mt(myMutex,qApp);
- //myScaleFactor[theAxis] = theParam;
- ScaleView(myStudyFrame,theAxis,theParam);
+ double aScale[3];
+ GetViewFrame(myStudyFrame)->GetScale(aScale);
+ aScale[theAxis] = theParam;
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myStudyFrame,aScale));
}
void View3D_i::RemoveScale() {
if(MYDEBUG) MESSAGE("View3D_i::RemoveScale");
- Mutex mt(myMutex,qApp);
- double aScaleFactor[]={1,1,1};
- //myScaleFactor[0] = myScaleFactor[0] = myScaleFactor[0] = 1.0;
- GetViewFrame(myStudyFrame)->SetScale(aScaleFactor);
+ double aScale[3] = {1.0, 1.0, 1.0};
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myStudyFrame,aScale));
}
//===========================================================================
}
