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();
}
+
+
+ class TRepaintViewEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ public:
+ TRepaintViewEvent(QAD_StudyFrame* theStudyFrame):
+ myStudyFrame(theStudyFrame)
+ {}
+ virtual bool Execute(){
+ RepaintView(myStudyFrame);
+ return true;
+ }
+ };
+
+
VISU_Actor* UpdateViewer(QAD_StudyFrame* theStudyFrame, int theDisplaing, Prs3d_i* thePrs){
VTKViewer_ViewFrame* vf = GetViewFrame(theStudyFrame);
if (!vf) return NULL;
//===========================================================================
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);
}
-
- VISU::View3D_ptr ViewManager_i::Create3DView(){
- if(MYDEBUG) MESSAGE("ViewManager_i::Create3DView");
-
+ VISU::View_ptr ViewManager_i::GetCurrentView(){
class TEvent: public SALOME_Event{
SALOMEDS::Study_ptr myStudyDocument;
public:
myStudyDocument(theStudy)
{}
virtual bool Execute(){
- if ( CheckStudy( myStudyDocument ) ) {
- VISU::View3D_i* pView = new View3D_i(myStudyDocument);
- if(pView->Create(1) != NULL)
- myResult = pView->_this();
+ 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 CORBA::is_nil(myResult.in());
+ return true;
}
- typedef VISU::View3D_var TResult;
+ 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 ) {
+
+ class TCreate3DViewEvent: public TCreateViewEvent{
+ public:
+ typedef VISU::View3D TInterface;
+ typedef TInterface::_ptr_type TResult;
+ TResult myResult;
+ TCreate3DViewEvent( SALOMEDS::Study_ptr theStudy):
+ TCreateViewEvent(theStudy),
+ myResult(TInterface::_nil())
+ {}
+ virtual bool Execute(){
+ if ( CheckStudy( myStudyDocument ) ) {
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());
+ if(pView->Create(1) != NULL)
+ myResult = pView->_this();
}
+ return true;
}
- return VISU::View::_nil();
+ };
+ VISU::View3D_ptr ViewManager_i::Create3DView(){
+ if(MYDEBUG) MESSAGE("ViewManager_i::Create3DView");
+ return ProcessEvent(new TCreate3DViewEvent(myStudyDocument));
}
+
VISU::XYPlot_ptr ViewManager_i::CreateXYPlot(){
if(MYDEBUG) MESSAGE("ViewManager_i::CreateXYPlot");
- VISU_ViewEvent* ve = new VISU_ViewEvent( VISU_Event::CreateXYPlot, true, this );
+
+ class TEvent: public TCreateViewEvent{
+ public:
+ TEvent( SALOMEDS::Study_ptr theStudy):
+ TCreateViewEvent(theStudy)
+ {}
+ virtual bool Execute(){
+ if ( CheckStudy( myStudyDocument ) ) {
+ VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument);
+ if(pView->Create(1) != NULL)
+ myResult = pView->_this();
+ }
+ return true;
+ }
+ typedef VISU::XYPlot_var TResult;
+ TResult myResult;
+ };
+
+ TEvent* ve = new TEvent(myStudyDocument);
ve->process();
- VISU::XYPlot_ptr aView = VISU::XYPlot::_narrow( ve->getView() );
+ TEvent::TResult aResult = ve->myResult;
ve->release();
- return aView;
+ return aResult._retn();
}
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");
- VISU_ViewEvent* ve = new VISU_ViewEvent( VISU_Event::CreateTableView, true, this );
- ve->setArg( theTable );
+ TEvent* ve = new TEvent(myStudyDocument,theTable);
ve->process();
- VISU::TableView_ptr aView = VISU::TableView::_narrow( ve->getView() );
+ TEvent::TResult aResult = ve->myResult;
ve->release();
- return aView;
+ return aResult._retn();
}
void ViewManager_i::Destroy(View_ptr theView){
- if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - "<<theView->_is_nil());
- VISU_ViewEvent* ve = new VISU_ViewEvent( VISU_Event::DestroyView, true, this );
- ve->setView( theView );
- ve->process();
- ve->release();
- }
-
- // SAN - QT_EVENT prototype
- // SALOME event handlers
- View3D_ptr ViewManager_i::OnCreate3DView() {
- Mutex mt(myMutex,qApp,MYDELAY);
- if(MYDEBUG) MESSAGE("ViewManager_i::OnCreate3DView");
- // Make sure that myStudyDocument is opened in the desktop
- if ( CheckStudy( myStudyDocument ) ) {
- VISU::View3D_i* pView = new View3D_i(myStudyDocument);
- if(pView->Create(1) != NULL)
- return VISU::View3D::_duplicate(pView->_this());
- }
- return VISU::View3D::_nil();
- }
-
- VISU::TableView_ptr ViewManager_i::OnCreateTableView(VISU::Table_ptr theTable){
- if(MYDEBUG) MESSAGE("ViewManager_i::OnCreateTableView");
- Mutex mt(myMutex,qApp,MYDELAY);
- if ( CheckStudy( myStudyDocument ) ) {
- 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();
- }
-
- VISU::XYPlot_ptr ViewManager_i::OnCreateXYPlot(){
- if(MYDEBUG) MESSAGE("ViewManager_i::OnCreateXYPlot");
- Mutex mt(myMutex,qApp,MYDELAY);
- if ( CheckStudy( myStudyDocument ) ) {
- VISU::XYPlot_i* pView = new XYPlot_i(myStudyDocument);
- if(pView->Create(1) != NULL)
- return VISU::XYPlot::_duplicate(pView->_this());
- }
- return VISU::XYPlot::_nil();
- }
-
- void ViewManager_i::OnDestroy(View_ptr theView){
- if(MYDEBUG) MESSAGE("ViewManager_i::OnDestroy - "<<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::OnDestroy - VISU::View"<<(!CORBA::is_nil(aView)));
- VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(aView).in());
- if(MYDEBUG) MESSAGE("ViewManager_i::OnDestroy - 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;
}
- return;
- }
+ };
+ if(MYDEBUG) MESSAGE("ViewManager_i::Destroy - "<<theView->_is_nil());
+ ProcessVoidEvent(new TEvent(theView));
}
- // SAN - QT_EVENT prototype
//===========================================================================
//===========================================================================
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());
void View3D_i::Update(){
- if(MYDEBUG) MESSAGE("View3D_i::Update");
-
class TEvent: public SALOME_Event{
QAD_StudyFrame* myStudyFrame;
public:
- TEvent( QAD_StudyFrame* theStudyFrame ):
+ TEvent(QAD_StudyFrame* theStudyFrame):
myStudyFrame(theStudyFrame)
{}
virtual bool Execute(){
}
}
}
- myResult = myStudyFrame->title().latin1();
return true;
}
- typedef string TResult;
- TResult myResult;
};
-
- TEvent* ve = new TEvent( myStudyFrame );
- ve->process();
- myName = ve->myResult;
- ve->release();
+ if(MYDEBUG) MESSAGE("View3D_i::Update");
+ myName = myStudyFrame->title().latin1();
+ ProcessVoidEvent(new TEvent(myStudyFrame));
}
+
CORBA::Boolean View3D_i::SavePicture(const char* theFileName) {
+ class TEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ const char* myFileName;
+ public:
+ typedef CORBA::Boolean TResult;
+ TResult myResult;
+ TEvent(QAD_StudyFrame* theStudyFrame,
+ const char* theFileName):
+ myStudyFrame(theStudyFrame),
+ myFileName(theFileName),
+ myResult(false)
+ {}
+ virtual bool Execute(){
+ QPixmap px = QPixmap::grabWindow(myStudyFrame->getRightFrame()->getViewFrame()->getViewWidget()->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());
+ }
+ }
+ };
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;
+ TEvent* ve = new TEvent(myStudyFrame,theFileName);
+ ve->process();
+ TEvent::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){
+ if(MYDEBUG) MESSAGE("View3D_i::SaveViewPoint");
+ 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) throw(std::logic_error&) {
- // 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;
+ };
+ if(MYDEBUG) MESSAGE("View3D_i::RestoreViewParams - "<<theName);
+ 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);
+ }
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){
+ 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(){
+ myStudyFrame->setTitle(myName);
+ return true;
+ }
+ };
if(MYDEBUG) MESSAGE("View3D_i::SetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
myName = theTitle;
- myStudyFrame->setTitle(myName.c_str());
+ ProcessVoidEvent(new TEvent(myStudyFrame,theTitle));
}
char* View3D_i::GetTitle() {
if(MYDEBUG) MESSAGE("View3D_i::GetTitle");
- Mutex mt(myMutex,qApp,MYDELAY);
- myName = (const char*)myStudyFrame->title();
+ myName = myStudyFrame->title().latin1();
return CORBA::string_dup(myName.c_str());
}
+
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) {
+ class TEvent: public SALOME_Event{
+ QAD_StudyFrame* myStudyFrame;
+ const SALOMEDS::Color& myColor;
+ public:
+ TEvent(QAD_StudyFrame* theStudyFrame,
+ const SALOMEDS::Color& theColor):
+ myStudyFrame(theStudyFrame),
+ myColor(theColor)
+ {}
+ virtual bool Execute(){
+ SetBackground(myStudyFrame,myColor);
+ return true;
+ }
+ };
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 TEvent(myStudyFrame,theColor));
}
+
SALOMEDS::Color View3D_i::GetBackground(QAD_StudyFrame* theStudyFrame) {
SALOMEDS::Color aColor;
float backint[3];
}
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);
}
+
+ class TFrameActionEvent: public SALOME_Event{
+ public:
+ typedef void (QAD_StudyFrame::* TFrameAction)();
+ TFrameActionEvent(QAD_StudyFrame* theStudyFrame,
+ TFrameAction theFrameAction):
+ myStudyFrame(theStudyFrame),
+ myFrameAction(theFrameAction)
+ {}
+ virtual bool Execute(){
+ (myStudyFrame->*myFrameAction)();
+ return true;
+ }
+ private:
+ QAD_StudyFrame* myStudyFrame;
+ TFrameAction myFrameAction;
+ };
+
+
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));
}
Prs3d_i* myPrs3d;
int myDisplaing;
public:
- TUpdateViewerEvent( QAD_StudyFrame* theStudyFrame,
- Prs3d_i* thePrs3d,
- int theDisplaing ):
+ TUpdateViewerEvent(QAD_StudyFrame* theStudyFrame,
+ Prs3d_i* thePrs3d,
+ int theDisplaing):
myStudyFrame(theStudyFrame),
myPrs3d(thePrs3d),
myDisplaing(theDisplaing)
void View3D_i::EraseAll() {
if(MYDEBUG) MESSAGE("View3D_i::EraseAll");
- ProcessVoidEvent(new TUpdateViewerEvent( myStudyFrame, NULL, eEraseAll ));
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,NULL,eEraseAll));
}
void View3D_i::DisplayAll() {
if(MYDEBUG) MESSAGE("View3D_i::DisplayAll");
- ProcessVoidEvent(new TUpdateViewerEvent( myStudyFrame, NULL, eDisplayAll ));
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,NULL,eDisplayAll));
}
void View3D_i::Erase(PrsObject_ptr thePrsObj) {
if(MYDEBUG) MESSAGE("View3D_i::Erase");
CORBA::Object_ptr anObj = thePrsObj;
if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent( myStudyFrame, aPrs, eErase ));
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eErase));
}
}
if(MYDEBUG) MESSAGE("View3D_i::Display");
CORBA::Object_ptr anObj = thePrsObj;
if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent( myStudyFrame, aPrs, eDisplay ));
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eDisplay));
}
}
if(MYDEBUG) MESSAGE("View3D_i::DisplayOnly");
CORBA::Object_ptr anObj = thePrsObj;
if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent( myStudyFrame, aPrs, eDisplayOnly ));
+ ProcessVoidEvent(new TUpdateViewerEvent(myStudyFrame,aPrs,eDisplayOnly));
}
}
class TViewActionEvent: public SALOME_Event{
public:
typedef void (VTKViewer_ViewFrame::* TViewAction)();
- TViewActionEvent( QAD_StudyFrame* theStudyFrame,
- TViewAction theViewAction ):
+ TViewActionEvent(QAD_StudyFrame* theStudyFrame,
+ TViewAction theViewAction):
myStudyFrame(theStudyFrame),
myViewAction(theViewAction)
{}
void View3D_i::FitAll() {
if(MYDEBUG) MESSAGE("View3D_i::FitAll");
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewFitAll ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewFitAll));
Update();
}
+
void View3D_i::SetView(VISU::View3D::ViewType theType) {
if(MYDEBUG) MESSAGE("View3D_i::SetView");
switch(theType){
case VISU::View3D::FRONT :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewFront ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewFront));
break;
case VISU::View3D::BACK :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewBack ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewBack));
break;
case VISU::View3D::LEFT :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewLeft ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewLeft));
break;
case VISU::View3D::RIGHT :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewRight ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewRight));
break;
case VISU::View3D::TOP :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewTop ));
+ ProcessVoidEvent(new TViewActionEvent(myStudyFrame,&VTKViewer_ViewFrame::onViewTop));
break;
case VISU::View3D::BOTTOM :
- ProcessVoidEvent(new TViewActionEvent( myStudyFrame, &VTKViewer_ViewFrame::onViewBottom ));
+ ProcessVoidEvent(new TViewActionEvent(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 thePosition) {
if(MYDEBUG) MESSAGE("View3D_i::SetPointOfView");
-
- class TEvent: public SALOME_Event{
- public:
- TEvent( QAD_StudyFrame* theStudyFrame,
- const CORBA::Double thePosition[3] ):
- myStudyFrame(theStudyFrame),
- myPosition(thePosition)
- {}
- virtual bool Execute(){
- SetPointOfView(myStudyFrame, myPosition);
- return true;
- }
- private:
- QAD_StudyFrame* myStudyFrame;
- const CORBA::Double* myPosition;
- };
-
- ProcessVoidEvent(new TEvent( myStudyFrame, thePosition));
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetPointOfView,myStudyFrame,thePosition));
}
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));
}
//===========================================================================
}
