// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : VISU_View_i.cc
#include "VISU_Gen_i.hh"
#include "VISU_Prs3d_i.hh"
#include "VISU_Table_i.hh"
+#include "VISU_ScalarMap_i.hh"
#include "VISU_ViewManager_i.hh"
#include "VisuGUI_TableDlg.h"
#include "VISU_Actor.h"
+#include "VISU_ScalarMapAct.h"
#include "SALOME_Event.hxx"
#include "SUIT_Tools.h"
#include "STD_MDIDesktop.h"
+#include "STD_TabDesktop.h"
#include "SVTK_ViewWindow.h"
#include "SVTK_ViewModel.h"
-#include "SPlot2d_ViewModel.h"
+#include "SPlot2d_ViewModel.h"
#include "Plot2d_ViewFrame.h"
-#include "Plot2d_ViewModel.h"
#include "SalomeApp_Application.h"
#include "SalomeApp_Study.h"
+#include <QtxWorkstack.h>
+
#include <qworkspace.h>
+#include <qimage.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
static int MYDEBUG = 0;
#endif
-namespace VISU{
+namespace VISU {
typedef TVoidMemFunEvent<SUIT_ViewWindow> TFrameActionEvent;
+ struct TNewViewEvent: public SALOME_Event
+ {
+ SalomeApp_Application* myApplication;
+ typedef QWidget* TResult;
+ TResult myResult;
+
+ TNewViewEvent (SalomeApp_Application* theApplication):
+ myApplication(theApplication),
+ myResult(NULL)
+ {}
+
+ virtual
+ void
+ Execute()
+ {
+ if (STD_MDIDesktop* aDesktop = dynamic_cast<STD_MDIDesktop*>(myApplication->desktop())) {
+ myResult = aDesktop->workspace();
+ }
+ }
+ };
+
View_i::
- View_i(SalomeApp_Application *theApplication,
- SUIT_ViewManager* theViewManager):
+ View_i (SalomeApp_Application *theApplication,
+ SUIT_ViewManager* theViewManager):
myApplication(theApplication),
myWorkspace(NULL),
myViewManager(theViewManager)
{
if(MYDEBUG) MESSAGE("View_i::View_i - "<<this);
- if(STD_MDIDesktop* aDesktop = dynamic_cast<STD_MDIDesktop*>(myApplication->desktop())){
- myWorkspace = aDesktop->workspace();
- }
+ myWorkspace = ProcessEvent(new TNewViewEvent(theApplication));
}
View_i::
{}
};
-
void
View_i::
- ShowPart(VISU::View::ViewRepresentation theViewRepresentation,
- CORBA::Boolean theState)
+ ShowPart (VISU::View::ViewRepresentation theViewRepresentation,
+ CORBA::Boolean theState)
{
struct TEvent: public TApplicationEvent
{
myApplication->setWindowShown(SalomeApp_Application::WT_LogWindow,myState);
break;
case VISU::View::VIEWER:{
- ViewManagerList aViewManagerList = myApplication->viewManagers();
- // to do something
- // ...
+ ViewManagerList mgrs = myApplication->viewManagers();
+ ViewManagerList::const_iterator anIt = mgrs.begin(), aLast = mgrs.end();
+ for( ; anIt!=aLast; anIt++ )
+ {
+ const QPtrVector<SUIT_ViewWindow>& views = (*anIt)->getViews();
+ for( int i=0; i<views.count(); i++ )
+ views[i]->setShown( myState );
+ }
break;
}}
}
ProcessVoidEvent(new TEvent(myApplication,theViewRepresentation,theState));
}
-
struct TPartShownEvent: public TApplicationEvent
{
VISU::View::ViewRepresentation myViewRepresentation;
break;
case VISU::View::VIEWER:{
ViewManagerList aViewManagerList = myApplication->viewManagers();
- // to do something
- // ...
+ ViewManagerList::const_iterator anIt = aViewManagerList.begin();
+ for( ; anIt != aViewManagerList.end(); anIt++ )
+ {
+ const QPtrVector<SUIT_ViewWindow>& views = (*anIt)->getViews();
+ for( int i=0; i<views.count(); i++ ) {
+ myResult = views[i]->isShown();
+ return;
+ }
+ }
+ myResult = false;
break;
}}
}
};
-
CORBA::Boolean
View_i::
- IsPartShown(VISU::View::ViewRepresentation theViewRepresentation)
+ IsPartShown (VISU::View::ViewRepresentation theViewRepresentation)
{
return ProcessEvent(new TPartShownEvent(myApplication,theViewRepresentation));
}
+ // Begin: New methods for view parameters management
+ struct TSplitEvent: public SALOME_Event
+ {
+ SalomeApp_Application * myApplication;
+ SUIT_ViewWindow * myVW;
+ Qt::Orientation myOrientation;
+ QtxWorkstack::SplitType mySplitType;
+
+ public:
+ TSplitEvent (SalomeApp_Application * theApplication,
+ SUIT_ViewWindow * theViewWindow,
+ Qt::Orientation theOrientation,
+ QtxWorkstack::SplitType theSplitType):
+ myApplication(theApplication),
+ myVW(theViewWindow),
+ myOrientation(theOrientation),
+ mySplitType(theSplitType)
+ {}
+
+ virtual void Execute()
+ {
+ SUIT_Desktop* desk = myApplication->desktop();
+ STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
+ if (tabDesk) {
+ QtxWorkstack* workstack = tabDesk->workstack();
+ if (workstack) {
+ workstack->Split(myVW, myOrientation, mySplitType);
+ }
+ }
+ }
+ };
+
+ void
+ View_i::
+ SplitRight()
+ {
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
+ Qt::Horizontal, QtxWorkstack::SPLIT_MOVE));
+ }
+
+ void
+ View_i::
+ SplitLeft()
+ {
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
+ Qt::Horizontal, QtxWorkstack::SPLIT_STAY));
+ }
+
+ void
+ View_i::
+ SplitBottom()
+ {
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
+ Qt::Vertical, QtxWorkstack::SPLIT_MOVE));
+ }
+
+ void
+ View_i::
+ SplitTop()
+ {
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
+ Qt::Vertical, QtxWorkstack::SPLIT_STAY));
+ }
+
+ void
+ View_i::
+ OnTop()
+ {
+ struct TOnTopEvent: public SALOME_Event
+ {
+ SUIT_ViewWindow * myVW;
+
+ public:
+ TOnTopEvent (SUIT_ViewWindow * theViewWindow):
+ myVW(theViewWindow)
+ {}
+
+ virtual void Execute()
+ {
+ if (myVW) {
+ myVW->setFocus();
+ }
+ }
+ };
+
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TOnTopEvent(aVW));
+ }
+
+ struct TAttractEvent: public SALOME_Event
+ {
+ SalomeApp_Application * myApplication;
+ SUIT_ViewWindow * myVW1;
+ SUIT_ViewWindow * myVW2;
+ bool myAttractAll;
+
+ public:
+ TAttractEvent (SalomeApp_Application * theApplication,
+ SUIT_ViewWindow * theViewWindow1,
+ SUIT_ViewWindow * theViewWindow2,
+ bool theAttractAll):
+ myApplication(theApplication),
+ myVW1(theViewWindow1),
+ myVW2(theViewWindow2),
+ myAttractAll(theAttractAll)
+ {}
+ virtual void Execute()
+ {
+ SUIT_Desktop* desk = myApplication->desktop();
+ STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
+ if (tabDesk) {
+ QtxWorkstack* workstack = tabDesk->workstack();
+ if (workstack) {
+ workstack->Attract(myVW1, myVW2, myAttractAll);
+ }
+ }
+ }
+ };
+
+ void
+ View_i::
+ Attract (VISU::View_ptr theView)
+ {
+ if (!CORBA::is_nil(theView)) {
+ if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
+ if (pView) {
+ SUIT_ViewWindow* aVW1 = GetViewWindow();
+ SUIT_ViewWindow* aVW2 = pView->GetViewWindow();
+ if (aVW1 && aVW2)
+ ProcessVoidEvent(new TAttractEvent(myApplication, aVW1, aVW2, false));
+ }
+ }
+ }
+ }
+
+ void
+ View_i::
+ AttractAll (VISU::View_ptr theView)
+ {
+ if (!CORBA::is_nil(theView)) {
+ if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
+ if (pView) {
+ SUIT_ViewWindow* aVW1 = GetViewWindow();
+ SUIT_ViewWindow* aVW2 = pView->GetViewWindow();
+ if (aVW1 && aVW2)
+ ProcessVoidEvent(new TAttractEvent(myApplication, aVW1, aVW2, true));
+ }
+ }
+ }
+ }
+
+ struct TSizePositionEvent: public SALOME_Event
+ {
+ SalomeApp_Application * myApplication;
+ SUIT_ViewWindow * myVW;
+ double myValue;
+ bool myIsSize;
+
+ public:
+ TSizePositionEvent (SalomeApp_Application * theApplication,
+ SUIT_ViewWindow * theViewWindow,
+ double theValue,
+ bool theIsSize):
+ myApplication(theApplication),
+ myVW(theViewWindow),
+ myValue(theValue),
+ myIsSize(theIsSize)
+ {}
+
+ virtual void Execute()
+ {
+ MESSAGE("TSizePositionEvent::Execute()");
+ SUIT_Desktop* desk = myApplication->desktop();
+ STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
+ if (tabDesk) {
+ QtxWorkstack* workstack = tabDesk->workstack();
+ if (workstack) {
+ if (myIsSize) {
+ //jfa to do:workstack->SetRelativeSizeInSplitter(myVW, myValue);
+ } else {
+ workstack->SetRelativePositionInSplitter(myVW, myValue);
+ }
+ }
+ }
+ }
+ };
+
+ void
+ View_i::
+ SetRelativePositionInSplitter (CORBA::Double thePosition)
+ {
+ if (thePosition < 0.0 || 1.0 < thePosition) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSizePositionEvent(myApplication, aVW, thePosition, false));
+ }
+
+ void
+ View_i::
+ SetRelativeSizeInSplitter (CORBA::Double theSize)
+ {
+ if (theSize < 0.0 || 1.0 < theSize) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSizePositionEvent(myApplication, aVW, theSize, true));
+ }
+
+ struct TWSSizePositionEvent: public SALOME_Event
+ {
+ SalomeApp_Application * myApplication;
+ SUIT_ViewWindow * myVW;
+ Qt::Orientation myOrientation;
+ double myValue;
+ bool myIsSize;
+
+ public:
+ TWSSizePositionEvent (SalomeApp_Application * theApplication,
+ SUIT_ViewWindow * theViewWindow,
+ Qt::Orientation theOrientation,
+ double theValue,
+ bool theIsSize):
+ myApplication(theApplication),
+ myVW(theViewWindow),
+ myOrientation(theOrientation),
+ myValue(theValue),
+ myIsSize(theIsSize)
+ {}
+
+ virtual void Execute()
+ {
+ MESSAGE("TWSSizePositionEvent::Execute()");
+ SUIT_Desktop* desk = myApplication->desktop();
+ STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
+ if (tabDesk) {
+ QtxWorkstack* workstack = tabDesk->workstack();
+ if (workstack) {
+ if (myIsSize) {
+ //jfa to do:workstack->SetRelativeSize(myVW, myOrientation, myValue);
+ } else {
+ workstack->SetRelativePosition(myVW, myOrientation, myValue);
+ }
+ }
+ }
+ }
+ };
+
+ void
+ View_i::
+ SetRelativePositionX (CORBA::Double thePosition)
+ {
+ if (thePosition < 0.0 || 1.0 < thePosition) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TWSSizePositionEvent(myApplication, aVW,
+ Qt::Horizontal, thePosition, false));
+ }
+
+ void
+ View_i::
+ SetRelativePositionY (CORBA::Double thePosition)
+ {
+ if (thePosition < 0.0 || 1.0 < thePosition) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TWSSizePositionEvent(myApplication, aVW,
+ Qt::Vertical, thePosition, false));
+ }
+
+ void
+ View_i::
+ SetRelativeSizeX (CORBA::Double theSize)
+ {
+ if (theSize < 0.0 || 1.0 < theSize) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TWSSizePositionEvent(myApplication, aVW,
+ Qt::Horizontal, theSize, true));
+ }
+
+ void
+ View_i::
+ SetRelativeSizeY (CORBA::Double theSize)
+ {
+ if (theSize < 0.0 || 1.0 < theSize) {
+ return;
+ }
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TWSSizePositionEvent(myApplication, aVW,
+ Qt::Vertical, theSize, true));
+ }
+ // End: New methods for view parameters management
+
+ // Begin: Old methods for view parameters management, they don't work now
struct TSetViewSize: public SALOME_Event
{
- SUIT_ViewWindow* myViewWindow;
+ SUIT_ViewWindow* myVW;
typedef void (QRect::* TAction)(int);
TAction myAction;
CORBA::Long mySize;
TSetViewSize(SUIT_ViewWindow* theViewWindow,
TAction theAction,
CORBA::Long theSize):
- myViewWindow(theViewWindow),
+ myVW(theViewWindow),
myAction(theAction),
mySize(theSize)
{}
void
Execute()
{
- if (QWidget* aParent = myViewWindow->parentWidget(true)) {
+ if (QWidget* aParent = myVW->parentWidget(true)) {
QRect aQRect = aParent->frameGeometry();
(aQRect.*myAction)(mySize);
aParent->setGeometry(aQRect);
}
};
-
void
View_i::
SetViewWidth(CORBA::Long theWidth)
ProcessVoidEvent(new TSetViewSize(myViewWindow,&QRect::setWidth,theWidth));
}
-
void
View_i::
SetViewHeight(CORBA::Long theHeight)
struct TGetViewSize: public SALOME_Event
{
- SUIT_ViewWindow* myViewWindow;
+ SUIT_ViewWindow* myVW;
typedef int (QRect::* TAction)() const;
TAction myAction;
public:
TGetViewSize(SUIT_ViewWindow* theViewWindow,
TAction theAction):
- myViewWindow(theViewWindow),
+ myVW(theViewWindow),
myAction(theAction)
{}
void
Execute()
{
- if(QWidget* aParent = myViewWindow->parentWidget(true)){
+ if(QWidget* aParent = myVW->parentWidget(true)){
QRect aQRect = aParent->frameGeometry();
myResult = (aQRect.*myAction)();
}
class TWorkspaceEvent: public SALOME_Event
{
protected:
- QWidget* myViewWindow;
+ QWidget* myVW;
QWidget* myWorkspace;
public:
TWorkspaceEvent(QWidget* theViewWindow,
QWidget* theWorkspace):
- myViewWindow(theViewWindow),
+ myVW(theViewWindow),
myWorkspace(theWorkspace)
{}
};
void
Execute()
{
- if(QWidget* aParent = myViewWindow->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget(true))
SUIT_Tools::alignWidget(aParent,myWorkspace,myAligment);
}
};
void
View_i::
- SetViewPositionHorizontal(VISU::View::ViewPosition theViewPosition)
+ SetViewPositionHorizontal (VISU::View::ViewPosition theViewPosition)
{
- if(myWorkspace){
- switch(theViewPosition){
+ if (myWorkspace) {
+ switch (theViewPosition) {
case VISU::View::LEFT:
ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignLeft));
break;
void
View_i::
- SetViewPositionVertical(VISU::View::ViewPosition theViewPosition)
+ SetViewPositionVertical (VISU::View::ViewPosition theViewPosition)
{
- if(myWorkspace){
- switch(theViewPosition){
+ if (myWorkspace) {
+ switch (theViewPosition) {
case VISU::View::TOP:
ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignTop));
break;
void
View_i::
- SetRelativePosition(CORBA::Double theX, CORBA::Double theY)
+ SetRelativePosition (CORBA::Double theX, CORBA::Double theY)
{
struct TEvent: public TXYEvent
{
void
Execute()
{
- if(QWidget* aParent = myViewWindow->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget(true))
aParent->move(int(myX*myWorkspace->width()),int(myY*myWorkspace->height()));
}
};
- if(myWorkspace)
+ if (myWorkspace)
ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
}
void
View_i::
- SetRelativeSize(CORBA::Double theX, CORBA::Double theY)
+ SetRelativeSize (CORBA::Double theX, CORBA::Double theY)
{
struct TEvent: public TXYEvent
{
void
Execute()
{
- if(QWidget* aParent = myViewWindow->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget(true))
aParent->setGeometry(aParent->x(),
aParent->y(),
int(myX*myWorkspace->width()),
}
};
- if(myWorkspace)
+ if (myWorkspace)
ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
}
+ // End: Old methods for view parameters management, they don't work now
void
View_i::
- SetBackground(const SALOMEDS::Color& theColor)
+ SetBackground (const SALOMEDS::Color& theColor)
{
struct TEvent: public SALOME_Event
{
}
};
- ProcessVoidEvent(new TEvent(myViewWindow,theColor));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TEvent(aVW, theColor));
}
View_i::
GetBackground()
{
- return ProcessEvent(new TBackgroundEvent(myViewWindow));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ return ProcessEvent(new TBackgroundEvent(aVW));
+
+ SALOMEDS::Color aBlack;
+ aBlack.R = 0.0;
+ aBlack.G = 0.0;
+ aBlack.B = 0.0;
+ return aBlack;
}
void
View_i::
Minimize()
{
- ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMinimized));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TFrameActionEvent(aVW, &SUIT_ViewWindow::showMinimized));
}
void
View_i::
Restore()
{
- ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showNormal));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TFrameActionEvent(aVW, &SUIT_ViewWindow::showNormal));
}
void
View_i::
Maximize()
{
- ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMaximized));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TFrameActionEvent(aVW, &SUIT_ViewWindow::showMaximized));
}
void
void
View_i::
- Erase(PrsObject_ptr thePrsObj)
+ Erase (PrsObject_ptr thePrsObj)
{}
void
View_i::
- Display(PrsObject_ptr thePrsObj)
+ Display (PrsObject_ptr thePrsObj)
{}
void
View_i::
- DisplayOnly(PrsObject_ptr thePrsObj)
+ DisplayOnly (PrsObject_ptr thePrsObj)
{}
void
Update()
{}
- CORBA::Boolean
- View_i::SavePicture(const char* theFileName)
- {
- return false;
- }
-
- const char*
- View_i::
- GetComment() const
- {
- return "";
- }
- void
- View_i::
- ToStream(std::ostringstream& theStr)
- {}
-
-
- //================= OLD CODE ===================
-
- //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");
- // }
- // }
- // return aStudy;
- //}
-
class TSavePictureEvent: public SALOME_Event
{
- QWidget* myWidget;
- const char* myFileName;
+ SUIT_ViewWindow * myVW;
+ const char * myFileName;
public:
typedef CORBA::Boolean TResult;
TResult myResult;
- TSavePictureEvent (QWidget* theWidget, const char* theFileName)
- : myWidget(theWidget),
+ TSavePictureEvent (SUIT_ViewWindow * theViewWindow, const char * theFileName)
+ : myVW(theViewWindow),
myFileName(theFileName),
myResult(false)
{
virtual void Execute()
{
- if (myWidget) {
- QPixmap px = QPixmap::grabWindow(myWidget->winId());
- if (!QString(myFileName).isNull()) {
- QString fmt = SUIT_Tools::extension(myFileName).upper();
- if (fmt.isEmpty())
- fmt = QString("BMP"); // default format
- if (fmt == "JPG")
- fmt = "JPEG";
- myResult = px.save(myFileName, fmt.latin1());
- }
+ if (myVW) {
+ QImage img = myVW->dumpView();
+ if (!img.isNull()) {
+ QString fileName (myFileName);
+ if (!fileName.isEmpty()) {
+ QString fmt = SUIT_Tools::extension(fileName).upper();
+ if (fmt.isEmpty()) fmt = QString("BMP"); // default format
+ if (fmt == "JPG" ) fmt = "JPEG";
+ //QApplication::setOverrideCursor(Qt::waitCursor);
+ img.save(fileName, fmt.latin1());
+ myResult = true;
+ //QApplication::restoreOverrideCursor();
+ }
+ }
}
}
};
+ CORBA::Boolean
+ View_i::SavePicture(const char* theFileName)
+ {
+ return ProcessEvent(new TSavePictureEvent (GetViewWindow(), theFileName));
+ }
+
+ const char*
+ View_i::GetComment() const
+ {
+ return "";
+ }
+
+ void
+ View_i::
+ ToStream (std::ostringstream& theStr)
+ {
+ }
+
+ SUIT_ViewWindow* View_i::GetViewWindow()
+ {
+ if (myViewWindow) {
+ QPtrVector<SUIT_ViewWindow> aViews = myViewManager->getViews();
+ int aPos = aViews.find(myViewWindow);
+ if (aPos < 0)
+ myViewWindow = NULL;
+ }
+ return myViewWindow;
+ }
+
+ void View_i::SetViewWindow(SUIT_ViewWindow* theViewWindow)
+ {
+ myViewWindow = theViewWindow;
+ }
+
//===========================================================================
XYPlot_i::XYPlot_i (SalomeApp_Application* theApplication)
: View_i(theApplication, NULL)
{
if (MYDEBUG) MESSAGE("XYPlot_i::XYPlot_i");
- if (theApplication) {
- myViewManager = theApplication->getViewManager(Plot2d_Viewer::Type(), true);
- }
}
- Storable* XYPlot_i::Create (int theNew)
+ struct TCreatePlot2dViewEvent: public SALOME_Event
{
- if (theNew) {
- myViewWindow = myViewManager->createViewWindow();
- } else {
- myViewWindow = myViewManager->getActiveView();
- }
- ////myView = dynamic_cast<Plot2d_ViewFrame*>(myViewWindow->getRightFrame()->getViewFrame());
- //SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(myViewManager->getViewModel());
- //myView = aView->getActiveViewFrame();
- if (myViewWindow) {
- Plot2d_ViewWindow* aPlot2dVW = dynamic_cast<Plot2d_ViewWindow*>(myViewWindow);
- if (aPlot2dVW) {
- myView = aPlot2dVW->getViewFrame();
- if (myView) {
- myView->Repaint();
- }
+ XYPlot_i * myPlot2dView;
+ int myNew;
+
+ typedef Plot2d_ViewFrame* TResult;
+ TResult myResult;
+
+ TCreatePlot2dViewEvent (XYPlot_i * thePlot2dView,
+ const int theNew):
+ myPlot2dView(thePlot2dView),
+ myNew(theNew),
+ myResult(NULL)
+ {}
+
+ virtual
+ void
+ Execute()
+ {
+ if (!myPlot2dView->myApplication)
+ return;
+
+ SUIT_ViewManager* aViewMgr =
+ myPlot2dView->myApplication->getViewManager(SPlot2d_Viewer::Type(), false);
+ SUIT_ViewWindow* aVW = NULL;
+
+ if (aViewMgr) {
+ if (myNew)
+ aVW = aViewMgr->createViewWindow();
+ else
+ aVW = aViewMgr->getActiveView();
+ } else {
+ if (myNew) {
+ aViewMgr = myPlot2dView->myApplication->getViewManager(SPlot2d_Viewer::Type(), true);
+ aVW = aViewMgr->getActiveView();
+ } else {
+ return; // there are no current Plot2d view
+ }
+ }
+
+ if (aVW) {
+ Plot2d_ViewWindow* aPlot2dVW = dynamic_cast<Plot2d_ViewWindow*>(aVW);
+ if (aPlot2dVW) {
+ myResult = aPlot2dVW->getViewFrame();
+ if (myResult) {
+ myResult->Repaint();
+ }
+
+ myPlot2dView->myViewManager = aViewMgr;
+ myPlot2dView->SetViewWindow(aVW);
+ }
}
}
- return this;
+ };
+
+ Storable* XYPlot_i::Create (int theNew)
+ {
+ myView = ProcessEvent(new TCreatePlot2dViewEvent(this, theNew));
+ if (myView)
+ return this;
+ return NULL;
}
void XYPlot_i::Update()
void XYPlot_i::Close()
{
- myViewWindow->close();
+ //jfa: may be need to be enclosed in SALOME_Event?
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ aVW->close();
+ //QPtrVector<SUIT_ViewWindow> aViews = myViewManager->getViews();
+ //int aPos = aViews.find(myViewWindow);
+ //if (aPos >= 0)
+ // myViewWindow->close();
}
XYPlot_i::~XYPlot_i() {
void XYPlot_i::SetTitle (const char* theTitle)
{
- ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
- (myViewWindow, &SUIT_ViewWindow::setCaption, QString(theTitle)));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
+ (aVW, &SUIT_ViewWindow::setCaption, QString(theTitle)));
}
char* XYPlot_i::GetTitle()
{
- return CORBA::string_dup(myViewWindow->caption().latin1());
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ return CORBA::string_dup(aVW->caption().latin1());
+ return CORBA::string_dup("");
}
void XYPlot_i::SetSubTitle (const char* theTitle)
{
- ProcessVoidEvent(new TVoidMemFun1ArgEvent<Plot2d_ViewFrame,const QString&,QString>
- (myView, &Plot2d_ViewFrame::setTitle, QString(theTitle)));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<Plot2d_ViewFrame,const QString&,QString>
+ (myView, &Plot2d_ViewFrame::setTitle, QString(theTitle)));
}
char* XYPlot_i::GetSubTitle()
{
- return CORBA::string_dup(myView->getTitle());
+ if (GetViewWindow())
+ return CORBA::string_dup(myView->getTitle());
+ return CORBA::string_dup("");
}
void XYPlot_i::SetCurveType (VISU::XYPlot::CurveType theType)
{
- ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
- (myView,&Plot2d_ViewFrame::setCurveType,theType,true));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
+ (myView,&Plot2d_ViewFrame::setCurveType,theType,true));
}
VISU::XYPlot::CurveType XYPlot_i::GetCurveType()
{
- return (VISU::XYPlot::CurveType)myView->getCurveType();
+ if (GetViewWindow())
+ return (VISU::XYPlot::CurveType)myView->getCurveType();
+ return VISU::XYPlot::POINTS;
}
void XYPlot_i::SetMarkerSize (CORBA::Long theSize)
{
- ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
- (myView,&Plot2d_ViewFrame::setMarkerSize,theSize,true));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
+ (myView,&Plot2d_ViewFrame::setMarkerSize,theSize,true));
}
CORBA::Long XYPlot_i::GetMarkerSize()
{
- return myView->getMarkerSize();
+ if (GetViewWindow())
+ return myView->getMarkerSize();
+ return -1;
}
- class TEnableGridEvent: public SALOME_Event
- {
- public:
- typedef void (Plot2d_ViewFrame::* TFun)(bool, const int, bool, const int, bool);
- TEnableGridEvent (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 void Execute()
- {
- (myView->*myFun)(myMajor,myNumMajor,myMinor,myNumMinor,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)
{
- ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setXGrid,
- theMajor,theNumMajor,theMinor,theNumMinor));
+ class TEvent: public SALOME_Event
+ {
+ public:
+ TEvent (Plot2d_ViewFrame* theView,
+ CORBA::Boolean theMajor,
+ CORBA::Long theNumMajor,
+ CORBA::Boolean theMinor,
+ CORBA::Long theNumMinor):
+ myView(theView),
+ myMajor(theMajor),
+ myNumMajor(theNumMajor),
+ myMinor(theMinor),
+ myNumMinor(theNumMinor)
+ {}
+
+ virtual void Execute()
+ {
+ myView->setXGrid( myMajor, myNumMajor, myMinor, myNumMinor );
+ }
+ protected:
+ Plot2d_ViewFrame* myView;
+ CORBA::Boolean myMajor, myMinor;
+ CORBA::Long myNumMajor, myNumMinor;
+ };
+
+ if ( GetViewWindow() )
+ ProcessVoidEvent( new TEvent( myView, theMajor, theNumMajor, theMinor, theNumMinor ) );
}
- void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor,
- CORBA::Boolean theMinor, CORBA::Long theNumMinor)
+ void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor,
+ CORBA::Long theNumMajor,
+ CORBA::Boolean theMinor,
+ CORBA::Long theNumMinor)
{
- //jfa tmp:ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setYGrid,
- //jfa tmp: theMajor,theNumMajor,theMinor,theNumMinor));
+ this->EnableYGrid( theMajor, theNumMajor, theMinor, theNumMinor, false, 0, false, 0 );
}
+ void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor,
+ CORBA::Long theNumMajor,
+ CORBA::Boolean theMinor,
+ CORBA::Long theNumMinor,
+ CORBA::Boolean the2Major,
+ CORBA::Long the2NumMajor,
+ CORBA::Boolean the2Minor,
+ CORBA::Long the2NumMinor)
+ {
+ class TEvent: public SALOME_Event
+ {
+ public:
+ TEvent (Plot2d_ViewFrame* theView,
+ CORBA::Boolean theMajor,
+ CORBA::Long theNumMajor,
+ CORBA::Boolean theMinor,
+ CORBA::Long theNumMinor,
+ CORBA::Boolean the2Major,
+ CORBA::Long the2NumMajor,
+ CORBA::Boolean the2Minor,
+ CORBA::Long the2NumMinor):
+ myView(theView),
+ myMajor(theMajor),
+ myNumMajor(theNumMajor),
+ myMinor(theMinor),
+ myNumMinor(theNumMinor),
+ my2Major(the2Major),
+ my2NumMajor(the2NumMajor),
+ my2Minor(the2Minor),
+ my2NumMinor(the2NumMinor)
+ {}
+
+ virtual void Execute()
+ {
+ myView->setYGrid( myMajor, myNumMajor, myMinor, myNumMinor,
+ my2Major, my2NumMajor, my2Minor, my2NumMinor);
+ }
+ protected:
+ Plot2d_ViewFrame* myView;
+ CORBA::Boolean myMajor, myMinor, my2Major, my2Minor;
+ CORBA::Long myNumMajor, myNumMinor, my2NumMajor, my2NumMinor;
+ };
+
+ if (GetViewWindow())
+ ProcessVoidEvent( new TEvent( myView, theMajor, theNumMajor, theMinor, theNumMinor,
+ the2Major, the2NumMajor, the2Minor, the2NumMinor ) );
+ }
+
class TSetScaleModeEvent: public SALOME_Event
{
public:
void XYPlot_i::SetHorScaling (VISU::Scaling theScaling)
{
- ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setHorScaleMode,
- theScaling == VISU::LOGARITHMIC));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setHorScaleMode,
+ theScaling == VISU::LOGARITHMIC));
}
VISU::Scaling XYPlot_i::GetHorScaling()
{
- return (VISU::Scaling)myView->getHorScaleMode();
+ //jfa: may be need to be enclosed in SALOME_Event?
+ if (GetViewWindow())
+ return (VISU::Scaling)myView->getHorScaleMode();
+ return VISU::LINEAR;
}
void XYPlot_i::SetVerScaling(VISU::Scaling theScaling)
{
- ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setVerScaleMode,
- theScaling == VISU::LOGARITHMIC));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setVerScaleMode,
+ theScaling == VISU::LOGARITHMIC));
}
VISU::Scaling XYPlot_i::GetVerScaling()
{
- return (VISU::Scaling)myView->getVerScaleMode();
+ if (GetViewWindow())
+ return (VISU::Scaling)myView->getVerScaleMode();
+ return VISU::LINEAR;
}
class TSetTitleEvent: public SALOME_Event
{
public:
- //typedef void (Plot2d_ViewFrame::* TFun)(bool, const QString&, bool = true);
- typedef void (Plot2d_ViewFrame::* TFun)(bool, const QString&, Plot2d_ViewFrame::ObjectType, bool = true);
- //TSetTitleEvent (Plot2d_ViewFrame* theView, TFun theFun, const char* theTitle):
TSetTitleEvent (Plot2d_ViewFrame* theView, Plot2d_ViewFrame::ObjectType theType, const char* theTitle):
- //myView(theView), myFun(theFun), myTitle(theTitle)
myView(theView), myType(theType), myTitle(theTitle)
{}
virtual void Execute()
{
- //(myView->*myFun)(true,myTitle,myType);
myView->setTitle(true,myTitle,myType);
}
protected:
Plot2d_ViewFrame* myView;
- //TFun myFun;
Plot2d_ViewFrame::ObjectType myType;
const char* myTitle;
};
void XYPlot_i::SetXTitle (const char* theTitle)
{
- //ProcessVoidEvent(new TSetTitleEvent(myView, &Plot2d_ViewFrame::setXTitle, theTitle));
- ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::XTitle, theTitle));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::XTitle, theTitle));
}
char* XYPlot_i::GetXTitle()
{
- //return CORBA::string_dup(myView->getXTitle());
- return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::XTitle));
+ if (GetViewWindow())
+ return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::XTitle));
+ return CORBA::string_dup("");
}
void XYPlot_i::SetYTitle (const char* theTitle)
{
- //ProcessVoidEvent(new TSetTitleEvent(myView, &Plot2d_ViewFrame::setYTitle, theTitle));
- ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::YTitle, theTitle));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::YTitle, theTitle));
}
char* XYPlot_i::GetYTitle()
{
- //return CORBA::string_dup(myView->getYTitle());
- return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::YTitle));
+ if (GetViewWindow())
+ return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::YTitle));
+ return CORBA::string_dup("");
}
void XYPlot_i::ShowLegend (CORBA::Boolean theShowing)
{
- ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,bool,bool>
- (myView,&Plot2d_ViewFrame::showLegend,theShowing,true));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,bool,bool>
+ (myView,&Plot2d_ViewFrame::showLegend,theShowing,true));
}
class TXYPlotViewEvent: public SALOME_Event
}
}
if (!aCStudy) return;
- _PTR(SObject) TableSO = aCStudy->FindObjectID(aTable->GetEntry().latin1());
+ _PTR(SObject) TableSO = aCStudy->FindObjectID(aTable->GetEntry());
if (TableSO) {
_PTR(ChildIterator) Iter = aCStudy->NewChildIterator(TableSO);
for (; Iter->More(); Iter->Next()) {
void XYPlot_i::Display (PrsObject_ptr thePrsObj)
{
- ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplay));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplay));
}
void XYPlot_i::Erase (PrsObject_ptr thePrsObj)
{
- ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eErase));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eErase));
}
void XYPlot_i::DisplayOnly (PrsObject_ptr thePrsObj)
{
- ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplayOnly));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplayOnly));
}
void XYPlot_i::EraseAll()
{
- ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::EraseAll));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::EraseAll));
}
void XYPlot_i::FitAll()
{
- ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::fitAll));
+ if (GetViewWindow())
+ ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::fitAll));
}
- CORBA::Boolean XYPlot_i::SavePicture (const char* theFileName)
+ class TFitRangeEvent: public SALOME_Event
{
- return ProcessEvent(new TSavePictureEvent (myView->getViewWidget(),theFileName));
+ public:
+ TFitRangeEvent (Plot2d_ViewFrame* theView,
+ const int mode,
+ const double xMin, const double xMax,
+ const double yMin, const double yMax):
+ myView(theView),
+ myMode(mode),
+ myXMin(xMin),myXMax(xMax),
+ myYMin(yMin),myYMax(yMax)
+ {}
+ virtual void Execute()
+ {
+ myView->fitData(myMode,myXMin,myXMax,myYMin,myYMax);
+ }
+ protected:
+ const int myMode;
+ const double myXMin;
+ const double myXMax;
+ const double myYMin;
+ const double myYMax;
+ Plot2d_ViewFrame* myView;
+ };
+
+ void XYPlot_i::FitXRange(const CORBA::Double xMin,const CORBA::Double xMax)
+ {
+ const CORBA::Long mode = 1;
+ const CORBA::Double yMin = 0.0;
+ const CORBA::Double yMax = 0.0;
+ ProcessVoidEvent(new TFitRangeEvent(myView,mode,xMin,xMax,yMin,yMax));
}
+ void XYPlot_i::FitYRange(const CORBA::Double yMin,const CORBA::Double yMax)
+ {
+ const CORBA::Long mode = 2;
+ const CORBA::Double xMin = 0.0;
+ const CORBA::Double xMax = 0.0;
+ ProcessVoidEvent(new TFitRangeEvent(myView,mode,xMin,xMax,yMin,yMax));
+ }
+
+ void XYPlot_i::FitRange(const CORBA::Double xMin,const CORBA::Double xMax,
+ const CORBA::Double yMin,const CORBA::Double yMax)
+ {
+ const CORBA::Long mode = 0;
+ ProcessVoidEvent(new TFitRangeEvent(myView,mode,xMin,xMax,yMin,yMax));
+ }
+
+ void XYPlot_i::GetFitRanges(double& xMin, double& xMax, double& yMin, double& yMax)
+ {
+ double y2Min,y2Max;
+ myView->getFitRanges(xMin,xMax,yMin,yMax,y2Min,y2Max);
+ }
//===========================================================================
TableView_i::TableView_i (SalomeApp_Application* theApplication)
{
}
- Storable* TableView_i::Create (VISU::Table_ptr theTable)
+ struct TCreateTableViewEvent: public SALOME_Event
{
- if (MYDEBUG) MESSAGE("TableView_i::Create - " << (!theTable->_is_nil()));
- if (!theTable->_is_nil()) {
- 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) {
+ SalomeApp_Application* myApplication;
+ VISU::Table_i* myTable;
+
+ typedef VisuGUI_TableDlg* TResult;
+ TResult myResult;
+
+ TCreateTableViewEvent (SalomeApp_Application* theApplication,
+ VISU::Table_i* theTable):
+ myApplication(theApplication),
+ myTable(theTable),
+ myResult(NULL)
+ {}
+
+ virtual
+ void
+ Execute()
+ {
+ if (myTable != NULL) {
if (SUIT_Study* aSStudy = myApplication->activeStudy()) {
if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
if (_PTR(Study) aCStudy = aStudy->studyDS()) {
- _PTR(SObject) aSObject = aCStudy->FindObjectID(table->GetObjectEntry());
+ _PTR(SObject) aSObject = aCStudy->FindObjectID(myTable->GetObjectEntry());
if (aSObject) {
- myView = new VisuGUI_TableDlg (myApplication->desktop(),
- aSObject,
- false,
- VisuGUI_TableDlg::ttAuto,
- Qt::Vertical);
- myView->show();
- return this;
+ myResult = new VisuGUI_TableDlg (myApplication->desktop(),
+ aSObject,
+ false,
+ VisuGUI_TableDlg::ttAuto,
+ Qt::Vertical);
+ myResult->show();
}
}
}
}
}
}
+ };
+
+ Storable* TableView_i::Create (VISU::Table_ptr theTable)
+ {
+ if (MYDEBUG) MESSAGE("TableView_i::Create - " << (!theTable->_is_nil()));
+ if (!theTable->_is_nil()) {
+ VISU::Table_i* table =
+ dynamic_cast<VISU::Table_i*>(VISU::GetServant(theTable).in());
+ if (MYDEBUG) MESSAGE("TableView_i::Create - dynamic_cast = " << table);
+
+ myView = ProcessEvent(new TCreateTableViewEvent(myApplication, table));
+ if (myView)
+ return this;
+ }
return NULL;
}
char* TableView_i::GetTitle()
{
+ //jfa: may be need to be enclosed in SALOME_Event?
return CORBA::string_dup(myView->caption().latin1());
- return "";
}
void TableView_i::Close()
{
+ //jfa: may be need to be enclosed in SALOME_Event?
myView->close();
}
: View_i(theApplication, NULL)
{
if (MYDEBUG) MESSAGE("View3D_i::View3D_i");
- if (theApplication) {
- myViewManager = theApplication->getViewManager(SVTK_Viewer::Type(), true);
- }
}
+ struct TCreateView3dEvent: public SALOME_Event
+ {
+ SalomeApp_Application *myApplication;
+ View3D_i * myView3D;
+ int myNew;
+
+ typedef SUIT_ViewWindow* TResult;
+ TResult myResult;
+
+ TCreateView3dEvent (SalomeApp_Application *theApplication,
+ View3D_i * theView3D,
+ const int theNew):
+ myApplication(theApplication),
+ myView3D(theView3D),
+ myNew(theNew),
+ myResult(NULL)
+ {}
+
+ virtual
+ void
+ Execute()
+ {
+ if (!myApplication)
+ return;
+
+ if(myNew){
+ if(SUIT_ViewManager* aViewManager = myApplication->getViewManager(SVTK_Viewer::Type(),false)){
+ myResult = aViewManager->createViewWindow();
+ myView3D->myViewManager = aViewManager;
+ }else{
+ if(SUIT_ViewManager* aViewManager = myApplication->getViewManager(SVTK_Viewer::Type(),true)){
+ myResult = aViewManager->getActiveView();
+ myView3D->myViewManager = aViewManager;
+ }
+ }
+ }else{
+ if(SUIT_ViewManager* aViewManager = myApplication->activeViewManager()){
+ if(SUIT_ViewWindow* aView = aViewManager->getActiveView()){
+ if(dynamic_cast<SVTK_ViewWindow*>(aView)){
+ myView3D->myViewManager = aViewManager;
+ myResult = aViewManager->getActiveView();
+ }
+ }
+ }else{
+ if(SUIT_ViewManager* aViewManager = myApplication->getViewManager(SVTK_Viewer::Type(),false)){
+ myView3D->myViewManager = aViewManager;
+ myResult = aViewManager->getActiveView();
+ }
+ }
+ }
+ }
+ };
+
Storable* View3D_i::Create (int theNew)
{
if (MYDEBUG) MESSAGE("View3D_i::Create");
- if (theNew) {
- myViewWindow = myViewManager->createViewWindow();
- } else {
- myViewWindow = myViewManager->getActiveView();
+ SUIT_ViewWindow* aVW = ProcessEvent(new TCreateView3dEvent(myApplication, this, theNew));
+ if (aVW) {
+ SetViewWindow(aVW);
+ return this;
}
- return this;
+ return NULL;
}
void View3D_i::Update()
{
SUIT_ViewWindow* myViewWindow;
public:
- TEvent(SUIT_ViewWindow* theStudyFrame):
- myViewWindow(theStudyFrame)
+ TEvent(SUIT_ViewWindow* theViewWindow):
+ myViewWindow(theViewWindow)
{}
virtual void Execute()
{
- SVTK_ViewWindow* vf = GetViewWindow(myViewWindow);
- vtkRenderer* Renderer = vf->getRenderer();
- vtkActorCollection* theActors = Renderer->GetActors();
- theActors->InitTraversal();
- while (vtkActor *anAct = theActors->GetNextActor()) {
+ SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>(myViewWindow);
+ vtkRenderer* aRenderer = aViewWindow->getRenderer();
+ vtkActorCollection* anActors = aRenderer->GetActors();
+ anActors->InitTraversal();
+ while (vtkActor *anAct = anActors->GetNextActor()) {
if (VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(anAct)) {
- VISU::Prs3d_i* aPrs3d = anActor->GetPrs3d();
- if (anActor->GetVisibility() && aPrs3d) {
- aPrs3d->Update();
- aPrs3d->UpdateActor(anActor);
- }
+ if (anActor->GetVisibility())
+ anActor->UpdateFromFactory();
}
}
RepaintView(myViewWindow);
}
};
- ProcessVoidEvent(new TEvent(myViewWindow));
- }
- CORBA::Boolean View3D_i::SavePicture (const char* theFileName)
- {
- //jfa tmp:return ProcessEvent(new TSavePictureEvent(myView->getViewWidget(), theFileName));
- return false;
+ if (SUIT_ViewWindow* aViewWindow = GetViewWindow())
+ ProcessVoidEvent(new TEvent(aViewWindow));
}
- bool View3D_i::SaveViewParams (SUIT_ViewManager* theViewManager, const char* theName)
+ bool View3D_i::SaveViewParams (SUIT_ViewManager* theViewManager, const std::string& theName)
{
+ MESSAGE("View3D_i::SaveViewParams()");
+
+ if (!theViewManager || theName == "")
+ return false;
+
_PTR(Study) aCStudy;
if (SUIT_Study* aSStudy = theViewManager->study()) {
if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
if (!aCStudy)
return false;
- if (theName) {
- std::vector<_PTR(SObject)> aList = aCStudy->FindObjectByName(theName, "VISU");
+ if (theName != "") {
+ std::vector<_PTR(SObject)> aList = aCStudy->FindObjectByName(theName.c_str(), "VISU");
_PTR(GenericAttribute) anAttr;
int iEnd = aList.size();
for (int i = 0; i < iEnd; i++) {
_PTR(SObject) anObj = aList[i];
string anEntry = anObj->GetID();
if(MYDEBUG) MESSAGE("View3D_i::SaveViewParams - anEntry = " << anEntry);
- if (anObj->FindAttribute(anAttr, "AttributeComment")) {
- _PTR(AttributeComment) aCmnt (anAttr);
+ if (anObj->FindAttribute(anAttr, "AttributeString")) {
+ _PTR(AttributeString) aCmnt (anAttr);
string aComm (aCmnt->Value());
if (MYDEBUG) MESSAGE("View3D_i::SaveViewPoint - aComm = " << aComm);
if (aComm.compare(View3D_i::myComment) >= 0) {
}
_PTR(SComponent) aSComponent = ClientFindOrCreateVisuComponent(aCStudy);
string aSComponentEntry = aSComponent->GetID();
- string anEntry = CreateAttributes(aCStudy, aSComponentEntry.c_str(), "", "", theName, "",
+ string anEntry = CreateAttributes(aCStudy,
+ aSComponentEntry.c_str(),
+ "",
+ "",
+ theName,
+ "",
ToString(theViewManager->getActiveView()).c_str());
return true;
}
- CORBA::Boolean View3D_i::SaveViewParams (const char* theName)
+ class TSaveViewParamsEvent: public SALOME_Event
{
- return SaveViewParams(myViewManager, theName);
+ SUIT_ViewManager* myViewMgr;
+ std::string myName;
+ public:
+ TSaveViewParamsEvent (SUIT_ViewManager* theViewManager,
+ const std::string& theName):
+ myViewMgr(theViewManager),
+ myName(theName)
+ {}
+
+ virtual void Execute()
+ {
+ myResult = View3D_i::SaveViewParams(myViewMgr, myName);
+ }
+ typedef CORBA::Boolean TResult;
+ TResult myResult;
+ };
+
+ CORBA::Boolean View3D_i::SaveViewParams (const char* theViewParamsName)
+ {
+ return ProcessEvent(new TSaveViewParamsEvent (myViewManager, theViewParamsName));
}
- bool View3D_i::RestoreViewParams (SUIT_ViewManager* theViewManager, const char* theName)
+ bool View3D_i::RestoreViewParams (SUIT_ViewManager* theViewManager, const std::string& theName)
{
_PTR(Study) aCStudy;
if (SUIT_Study* aSStudy = theViewManager->study()) {
_PTR(SObject) anObj = aList[i];
string anEntry = anObj->GetID();
if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - anEntry = " << anEntry);
- if (anObj->FindAttribute(anAttr, "AttributeComment")) {
- _PTR(AttributeComment) aCmnt (anAttr);
- QString strIn(aCmnt->Value().c_str());
- Storable::TRestoringMap aMap;
- Storable::StrToMap(strIn, aMap);
- if (Storable::FindValue(aMap, "myComment").compare
- (View3D_i::myComment.c_str()) >= 0) {
- if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - aComm = " << strIn);
- Restore(theViewManager->getActiveView(), aMap);
- return true;
- }
+ Storable::TRestoringMap aMap = Storable::GetStorableMap(anObj);
+ if (Storable::FindValue(aMap, "myComment") == View3D_i::myComment) {
+ Restore(theViewManager->getActiveView(), aMap);
+ return true;
}
}
return false;
class TRestoreViewParamsEvent: public SALOME_Event
{
- SUIT_ViewManager* myViewManager;
- const char* myName;
+ SUIT_ViewManager* myViewMgr;
+ std::string myName;
public:
TRestoreViewParamsEvent (SUIT_ViewManager* theViewManager,
- const char* theName):
- myViewManager(theViewManager),
+ const std::string& theName):
+ myViewMgr(theViewManager),
myName(theName)
{}
virtual void Execute()
{
- myResult = View3D_i::RestoreViewParams(myViewManager, myName);
+ myResult = View3D_i::RestoreViewParams(myViewMgr, myName);
}
typedef CORBA::Boolean TResult;
TResult myResult;
};
- CORBA::Boolean View3D_i::RestoreViewParams (const char* theName)
+ CORBA::Boolean View3D_i::RestoreViewParams (const char* theViewParamsName)
{
- return ProcessEvent(new TRestoreViewParamsEvent (myViewManager, theName));
+ return ProcessEvent(new TRestoreViewParamsEvent (myViewManager, theViewParamsName));
}
- void View3D_i::Restore (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::Restore (SUIT_ViewWindow* theViewWindow,
const Storable::TRestoringMap& theMap)
{
SALOMEDS::Color aColor;
aScaleFactor[1] = VISU::Storable::FindValue(theMap,"myScaleFactor[1]").toDouble();
aScaleFactor[2] = VISU::Storable::FindValue(theMap,"myScaleFactor[2]").toDouble();
- 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]);
+ SetBackground(theViewWindow,aColor);
+ SetPointOfView(theViewWindow,aPosition);
+ SetViewUp(theViewWindow,aViewUp);
+ SetFocalPoint(theViewWindow,aFocalPnt);
+ SetParallelScale(theViewWindow,aParallelScale);
+ ScaleView(theViewWindow,VISU::View3D::XAxis,aScaleFactor[0]);
+ ScaleView(theViewWindow,VISU::View3D::YAxis,aScaleFactor[1]);
+ ScaleView(theViewWindow,VISU::View3D::ZAxis,aScaleFactor[2]);
}
- string View3D_i::ToString (SUIT_ViewWindow* theStudyFrame)
+ string View3D_i::ToString (SUIT_ViewWindow* theViewWindow)
{
ostringstream strOut;
- Storable::DataToStream( strOut, "myComment", myComment.c_str() );
- ToStream(theStudyFrame,strOut);
- strOut<<ends;
- if(MYDEBUG) MESSAGE("View3D_i::ToString - "<<strOut.str());
+ Storable::DataToStream(strOut, "myComment", myComment.c_str());
+ ToStream(theViewWindow, strOut);
+ strOut << ends;
+ if(MYDEBUG) MESSAGE("View3D_i::ToString - " << strOut.str());
return strOut.str();
}
- void View3D_i::ToStream (SUIT_ViewWindow* theStudyFrame, std::ostringstream& theStr)
+ void View3D_i::ToStream (SUIT_ViewWindow* theViewWindow, std::ostringstream& theStr)
{
- Storable::DataToStream(theStr,"myType",VISU::TVIEW3D);
-
- float backint[3];
- GetRenderer(theStudyFrame)->GetBackground(backint);
+ vtkFloatingPointType backint[3];
+ GetRenderer(theViewWindow)->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(theStudyFrame,aPosition);
+ GetPointOfView(theViewWindow,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(theStudyFrame,aFocalPnt);
+ GetFocalPoint(theViewWindow,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(theStudyFrame)->GetViewUp(aViewUp);
+ GetCamera(theViewWindow)->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(theStudyFrame));
+ Storable::DataToStream(theStr,"myParallelScale",GetParallelScale(theViewWindow));
double aScaleFactor[3];
- GetViewWindow(theStudyFrame)->GetScale(aScaleFactor);
+ (dynamic_cast<SVTK_ViewWindow*>(theViewWindow))->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(myViewWindow,theStr);
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ToStream(aVW, theStr);
}
void View3D_i::Close()
{
- myViewWindow->close();
+ //jfa: may be need to be enclosed in SALOME_Event?
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ aVW->close();
+ //QPtrVector<SUIT_ViewWindow> aViews = myViewManager->getViews();
+ //int aPos = aViews.find(myViewWindow);
+ //if (aPos >= 0)
+ // myViewWindow->close();
}
View3D_i::~View3D_i()
void View3D_i::SetTitle (const char* theTitle)
{
- ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
- (myViewWindow,&SUIT_ViewWindow::setCaption,QString(theTitle)));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
+ (aVW,&SUIT_ViewWindow::setCaption,QString(theTitle)));
}
char* View3D_i::GetTitle()
{
- return CORBA::string_dup(myViewWindow->caption().latin1());
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ return CORBA::string_dup(aVW->caption().latin1());
+ return CORBA::string_dup("");
}
- void View3D_i::SetBackground (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::SetBackground (SUIT_ViewWindow* theViewWindow,
const SALOMEDS::Color& theColor)
{
+ //jfa: may be need to be enclosed in SALOME_Event?
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]);
- GetViewWindow(theStudyFrame)->setBackgroundColor(aNewColor);
+ QColor aNewColor (aColor[0],aColor[1],aColor[2]);
+ (dynamic_cast<SVTK_ViewWindow*>(theViewWindow))->setBackgroundColor(aNewColor);
}
- SALOMEDS::Color View3D_i::GetBackground (SUIT_ViewWindow* theStudyFrame)
+ SALOMEDS::Color View3D_i::GetBackground (SUIT_ViewWindow* theViewWindow)
{
SALOMEDS::Color aColor;
- float backint[3];
- GetRenderer(theStudyFrame)->GetBackground(backint);
+ vtkFloatingPointType backint[3];
+ GetRenderer(theViewWindow)->GetBackground(backint);
aColor.R = backint[0]; aColor.G = backint[1]; aColor.B = backint[2];
return aColor;
}
class TUpdateViewerEvent: public SALOME_Event
{
- SUIT_ViewWindow* myViewWindow;
+ SUIT_ViewWindow* myVW;
Prs3d_i* myPrs3d;
int myDisplaing;
public:
- TUpdateViewerEvent(SUIT_ViewWindow* theStudyFrame,
+ TUpdateViewerEvent(SUIT_ViewWindow* theViewWindow,
Prs3d_i* thePrs3d,
int theDisplaing):
- myViewWindow(theStudyFrame),
+ myVW(theViewWindow),
myPrs3d(thePrs3d),
myDisplaing(theDisplaing)
{}
virtual void Execute(){
- UpdateViewer(myViewWindow,myDisplaing,myPrs3d);
+ UpdateViewer(myVW, myDisplaing, myPrs3d);
}
};
void View3D_i::EraseAll()
{
if(MYDEBUG) MESSAGE("View3D_i::EraseAll");
- ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,NULL,eEraseAll));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TUpdateViewerEvent(aVW,NULL,eEraseAll));
}
void View3D_i::DisplayAll()
{
if(MYDEBUG) MESSAGE("View3D_i::DisplayAll");
- ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,NULL,eDisplayAll));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TUpdateViewerEvent(aVW,NULL,eDisplayAll));
}
void View3D_i::Erase (PrsObject_ptr thePrsObj)
{
if(MYDEBUG) MESSAGE("View3D_i::Erase");
+ SUIT_ViewWindow* aVW = GetViewWindow();
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eErase));
- }
+ Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
+ if (aVW && aPrs)
+ ProcessVoidEvent(new TUpdateViewerEvent(aVW,aPrs,eErase));
}
void View3D_i::Display (PrsObject_ptr thePrsObj)
{
if(MYDEBUG) MESSAGE("View3D_i::Display");
+ SUIT_ViewWindow* aVW = GetViewWindow();
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eDisplay));
- }
+ Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
+ if (aVW && aPrs)
+ ProcessVoidEvent(new TUpdateViewerEvent(aVW,aPrs,eDisplay));
}
void View3D_i::DisplayOnly (PrsObject_ptr thePrsObj)
{
if(MYDEBUG) MESSAGE("View3D_i::DisplayOnly");
+ SUIT_ViewWindow* aVW = GetViewWindow();
CORBA::Object_ptr anObj = thePrsObj;
- if(Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
- ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eDisplayOnly));
- }
+ Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
+ if (aVW && aPrs)
+ ProcessVoidEvent(new TUpdateViewerEvent(aVW,aPrs,eDisplayOnly));
}
void View3D_i::FitAll()
{
- ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onFitAll));
- Update();
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW) {
+ ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
+ (dynamic_cast<SVTK_ViewWindow*>(aVW), &SVTK_ViewWindow::onFitAll));
+ Update();
+ }
}
void View3D_i::SetView (VISU::View3D::ViewType theType)
{
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (!aVW)
+ return;
+
switch (theType) {
case VISU::View3D::FRONT :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onFrontView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW), &SVTK_ViewWindow::onFrontView));
break;
case VISU::View3D::BACK :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onBackView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW), &SVTK_ViewWindow::onBackView));
break;
case VISU::View3D::LEFT :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onLeftView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW),&SVTK_ViewWindow::onLeftView));
break;
case VISU::View3D::RIGHT :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onRightView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW),&SVTK_ViewWindow::onRightView));
break;
case VISU::View3D::TOP :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onTopView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW),&SVTK_ViewWindow::onTopView));
break;
case VISU::View3D::BOTTOM :
ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
- (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onBottomView));
+ (dynamic_cast<SVTK_ViewWindow*>(aVW),&SVTK_ViewWindow::onBottomView));
break;
}
Update();
class TSet3DViewParamEvent: public SALOME_Event
{
public:
- typedef void (*TFun)(SUIT_ViewWindow* theStudyFrame, const CORBA::Double theParam[3]);
+ typedef void (*TFun)(SUIT_ViewWindow* theViewWindow, const CORBA::Double theParam[3]);
TSet3DViewParamEvent (TFun theFun,
- SUIT_ViewWindow* theStudyFrame,
+ SUIT_ViewWindow* theViewWindow,
const CORBA::Double theParam[3]):
myFun(theFun),
- myViewWindow(theStudyFrame),
+ myVW(theViewWindow),
myParam(theParam)
{}
- virtual void Execute(){
- myFun(myViewWindow,myParam);
+ virtual void Execute() {
+ myFun(myVW,myParam);
}
private:
TFun myFun;
- SUIT_ViewWindow* myViewWindow;
+ SUIT_ViewWindow* myVW;
const CORBA::Double* myParam;
};
- void View3D_i::SetPointOfView (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::SetPointOfView (SUIT_ViewWindow* theViewWindow,
const CORBA::Double thePosition[3])
{
- GetCamera(theStudyFrame)->SetPosition(thePosition);
+ //jfa: may be need to be enclosed in SALOME_Event?
+ GetCamera(theViewWindow)->SetPosition(thePosition);
}
void View3D_i::SetPointOfView (const VISU::View3D::XYZ thePosition)
{
if(MYDEBUG) MESSAGE("View3D_i::SetPointOfView");
- ProcessVoidEvent(new TSet3DViewParamEvent(&SetPointOfView,myViewWindow,thePosition));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSet3DViewParamEvent(&View3D_i::SetPointOfView,aVW,thePosition));
}
- void View3D_i::GetPointOfView (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::GetPointOfView (SUIT_ViewWindow* theViewWindow,
CORBA::Double thePosition[3])
{
- GetCamera(theStudyFrame)->GetPosition(thePosition);
+ GetCamera(theViewWindow)->GetPosition(thePosition);
}
VISU::View3D::XYZ_slice* View3D_i::GetPointOfView()
{
if(MYDEBUG) MESSAGE("View3D_i::GetPointOfView");
CORBA::Double aPosition[3];
- GetPointOfView(myViewWindow,aPosition);
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ GetPointOfView(aVW,aPosition);
return VISU::View3D::XYZ_dup(aPosition);
}
- void View3D_i::SetViewUp (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::SetViewUp (SUIT_ViewWindow* theViewWindow,
const CORBA::Double theViewUp[3])
{
- GetCamera(theStudyFrame)->SetViewUp(theViewUp);
+ GetCamera(theViewWindow)->SetViewUp(theViewUp);
}
void View3D_i::SetViewUp (const VISU::View3D::XYZ theViewUp)
{
if(MYDEBUG) MESSAGE("View3D_i::SetViewUp");
- ProcessVoidEvent(new TSet3DViewParamEvent(&SetViewUp,myViewWindow,theViewUp));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSet3DViewParamEvent(&View3D_i::SetViewUp,aVW,theViewUp));
}
- void View3D_i::GetViewUp (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::GetViewUp (SUIT_ViewWindow* theViewWindow,
CORBA::Double theViewUp[3])
{
- GetCamera(theStudyFrame)->GetViewUp(theViewUp);
+ GetCamera(theViewWindow)->GetViewUp(theViewUp);
}
VISU::View3D::XYZ_slice* View3D_i::GetViewUp()
{
if(MYDEBUG) MESSAGE("View3D_i::GetViewUp");
CORBA::Double aViewUp[3];
- GetCamera(myViewWindow)->GetViewUp(aViewUp);
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ GetCamera(aVW)->GetViewUp(aViewUp);
return VISU::View3D::XYZ_dup(aViewUp);
}
- void View3D_i::SetFocalPoint (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::SetFocalPoint (SUIT_ViewWindow* theViewWindow,
const CORBA::Double theFocalPnt[3])
{
- GetCamera(theStudyFrame)->SetFocalPoint(theFocalPnt);
+ GetCamera(theViewWindow)->SetFocalPoint(theFocalPnt);
}
void View3D_i::SetFocalPoint (const VISU::View3D::XYZ theCoord)
{
if(MYDEBUG) MESSAGE("View3D_i::SetFocalPoint");
- ProcessVoidEvent(new TSet3DViewParamEvent(&SetFocalPoint,myViewWindow,theCoord));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSet3DViewParamEvent(&View3D_i::SetFocalPoint,aVW,theCoord));
}
- void View3D_i::GetFocalPoint (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::GetFocalPoint (SUIT_ViewWindow* theViewWindow,
CORBA::Double theFocalPnt[3])
{
- GetCamera(theStudyFrame)->GetFocalPoint(theFocalPnt);
+ GetCamera(theViewWindow)->GetFocalPoint(theFocalPnt);
}
VISU::View3D::XYZ_slice* View3D_i::GetFocalPoint()
{
if(MYDEBUG) MESSAGE("View3D_i::GetFocalPoint");
CORBA::Double aFocalPnt[3];
- GetFocalPoint(myViewWindow,aFocalPnt);
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ GetFocalPoint(aVW,aFocalPnt);
return VISU::View3D::XYZ_dup(aFocalPnt);
}
class TSetViewParamEvent: public SALOME_Event
{
public:
- typedef void (*TFun)(SUIT_ViewWindow* theStudyFrame, CORBA::Double theParam);
+ typedef void (*TFun)(SUIT_ViewWindow* theViewWindow, CORBA::Double theParam);
TSetViewParamEvent (TFun theFun,
- SUIT_ViewWindow* theStudyFrame,
+ SUIT_ViewWindow* theViewWindow,
CORBA::Double theParam):
myFun(theFun),
- myViewWindow(theStudyFrame),
+ myVW(theViewWindow),
myParam(theParam)
{}
virtual void Execute()
{
- myFun(myViewWindow,myParam);
+ myFun(myVW,myParam);
}
private:
TFun myFun;
- SUIT_ViewWindow* myViewWindow;
+ SUIT_ViewWindow* myVW;
CORBA::Double myParam;
};
- void View3D_i::SetParallelScale (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::SetParallelScale (SUIT_ViewWindow* theViewWindow,
CORBA::Double theScale)
{
- GetCamera(theStudyFrame)->SetParallelScale(theScale);
+ GetCamera(theViewWindow)->SetParallelScale(theScale);
}
void View3D_i::SetParallelScale (CORBA::Double theScale)
{
if(MYDEBUG) MESSAGE("View3D_i::SetParallelScale");
- ProcessVoidEvent(new TSetViewParamEvent(&SetParallelScale,myViewWindow,theScale));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ ProcessVoidEvent(new TSetViewParamEvent(&View3D_i::SetParallelScale,aVW,theScale));
}
- CORBA::Double View3D_i::GetParallelScale (SUIT_ViewWindow* theStudyFrame)
+ CORBA::Double View3D_i::GetParallelScale (SUIT_ViewWindow* theViewWindow)
{
- return GetCamera(theStudyFrame)->GetParallelScale();
+ return GetCamera(theViewWindow)->GetParallelScale();
}
CORBA::Double View3D_i::GetParallelScale()
{
if(MYDEBUG) MESSAGE("View3D_i::GetParallelScale");
- return GetParallelScale(myViewWindow);
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW)
+ return GetParallelScale(aVW);
+ return 1.0;
}
- void View3D_i::ScaleView (SUIT_ViewWindow* theStudyFrame,
+ void View3D_i::ScaleView (SUIT_ViewWindow* theViewWindow,
VISU::View3D::Axis theAxis, CORBA::Double theParam)
{
- SVTK_ViewWindow* aViewFrame = GetViewWindow(theStudyFrame);
+ SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>(theViewWindow);
double aScaleFactor[3];
- aViewFrame->GetScale(aScaleFactor);
+ aViewWindow->GetScale(aScaleFactor);
aScaleFactor[theAxis] = theParam;
- aViewFrame->SetScale(aScaleFactor);
+ aViewWindow->SetScale(aScaleFactor);
}
- void SetScaleView (SUIT_ViewWindow* theStudyFrame, const CORBA::Double theScale[3])
+ void SetScaleView (SUIT_ViewWindow* theViewWindow, const CORBA::Double theScale[3])
{
double aScale[3] = {theScale[0], theScale[1], theScale[2]};
- GetViewWindow(theStudyFrame)->SetScale(aScale);
+ (dynamic_cast<SVTK_ViewWindow*>(theViewWindow))->SetScale(aScale);
}
void View3D_i::ScaleView(VISU::View3D::Axis theAxis, CORBA::Double theParam)
{
if(MYDEBUG) MESSAGE("View3D_i::ScaleView");
- double aScale[3];
- GetViewWindow(myViewWindow)->GetScale(aScale);
- aScale[theAxis] = theParam;
- ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myViewWindow,aScale));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW) {
+ double aScale[3];
+ (dynamic_cast<SVTK_ViewWindow*>(aVW))->GetScale(aScale);
+ aScale[theAxis] = theParam;
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,aVW,aScale));
+ }
}
void View3D_i::RemoveScale()
{
if(MYDEBUG) MESSAGE("View3D_i::RemoveScale");
- double aScale[3] = {1.0, 1.0, 1.0};
- ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myViewWindow,aScale));
+ SUIT_ViewWindow* aVW = GetViewWindow();
+ if (aVW) {
+ double aScale[3] = {1.0, 1.0, 1.0};
+ ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,aVW,aScale));
+ }
+ }
+
+ //================================================
+ // Certain presentation view parameters management
+ //================================================
+ class TPrsManageEvent: public SALOME_Event
+ {
+ protected:
+ View3D_i* myView3D;
+ ScalarMap_ptr myPrs;
+ string myError;
+
+ TPrsManageEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ myView3D(theView3D),
+ myPrs(ScalarMap::_duplicate(thePrs)),
+ myError("Unknown error occured")
+ {}
+ VISU_Actor* GetMyActor()
+ {
+ SUIT_ViewWindow* aVW = myView3D->GetViewWindow();
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(aVW);
+ if (!aVW) {
+ myError = "Corrupted view window";
+ } else {
+ ScalarMap_i* aPrs = dynamic_cast<ScalarMap_i*>(VISU::GetServant(myPrs).in());
+ if (!aPrs) {
+ myError = "Corrupted presentation";
+ } else {
+ VISU_Actor* anActor = VISU::FindActor(vw, aPrs);
+ if (!anActor) {
+ myError = "No actor found. Display the presentation at first.";
+ } else {
+ myError = "";
+ return anActor;
+ }
+ }
+ }
+ return NULL;
+ }
+ };
+
+ // Get
+ class TGetPrsTypeEvent: public TPrsManageEvent {
+ public:
+ typedef VISU::PresentationType TResult;
+ TResult myResult;
+ TGetPrsTypeEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(VISU::SHRINK) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor())
+ myResult = (VISU::PresentationType)anActor->GetRepresentation();
+ }
+ };
+
+ class TGetShrinkedEvent: public TPrsManageEvent {
+ public:
+ typedef bool TResult;
+ TResult myResult;
+ TGetShrinkedEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(false) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ if (anActor->IsShrunkable())
+ myResult = anActor->IsShrunk();
+ else
+ myResult = false;
+ }
+ }
+ };
+
+ class TGetShadedEvent: public TPrsManageEvent {
+ public:
+ typedef bool TResult;
+ TResult myResult;
+ TGetShadedEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(false) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor())
+ if (VISU_ScalarMapAct* aScalarMapActor = dynamic_cast<VISU_ScalarMapAct*>(anActor))
+ myResult = aScalarMapActor->IsShading();
+ }
+ };
+
+ class TGetOpacityEvent: public TPrsManageEvent {
+ public:
+ typedef double TResult;
+ TResult myResult;
+ TGetOpacityEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(-1.0) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ vtkFloatingPointType oldvalue = anActor->GetOpacity();
+ myResult = (double)oldvalue;
+ }
+ }
+ };
+
+ class TGetLineWidthEvent: public TPrsManageEvent {
+ public:
+ typedef double TResult;
+ TResult myResult;
+ TGetLineWidthEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(-1.0) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ vtkFloatingPointType oldvalue = anActor->GetLineWidth();
+ myResult = (double)oldvalue;
+ }
+ }
+ };
+
+ // Set
+ class TSetPrsTypeEvent: public TPrsManageEvent {
+ private:
+ PresentationType myPrsType;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetPrsTypeEvent(View3D_i* theView3D, ScalarMap_ptr thePrs, PresentationType thePrsType):
+ TPrsManageEvent(theView3D, thePrs), myPrsType(thePrsType),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute() {
+ switch (myPrsType) {
+ case VISU::INSIDEFRAME:
+ {
+ VISU::VISUType aType = myPrs->GetType();
+ if (aType != VISU::TSCALARMAP &&
+ aType != VISU::TDEFORMEDSHAPE &&
+ aType != VISU::TSCALARMAPONDEFORMEDSHAPE) {
+ myResult = "Insideframe representation is not available for this type of presentations.";
+ return;
+ }
+ }
+ break;
+ case VISU::SURFACEFRAME:
+ myResult = "Surfaceframe representation is available only for mesh presentation.";
+ return;
+ case VISU::SHRINK:
+ myResult = "Use SetShrinked() method to shrink/unshrink presentation.";
+ return;
+ default:
+ break;
+ }
+ if (VISU_Actor* anActor = GetMyActor()) {
+ anActor->SetRepresentation((int)myPrsType);
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = myError;
+ }
+ }
+ };
+
+ class TSetShrinkedEvent: public TPrsManageEvent {
+ private:
+ bool myIsOn;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetShrinkedEvent(View3D_i* theView3D, ScalarMap_ptr thePrs, bool isOn):
+ TPrsManageEvent(theView3D, thePrs), myIsOn(isOn),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute() {
+ VISU::VISUType aType = myPrs->GetType();
+ if (aType == VISU::TVECTORS || aType == VISU::TSTREAMLINES) {
+ myResult = "Shrinked representation is not available for this type of presentations.";
+ } else {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ if (anActor->IsShrunkable()) {
+ if (myIsOn) anActor->SetShrink();
+ else anActor->UnShrink();
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = "This presentation is not shrunkable.";
+ }
+ } else {
+ myResult = myError;
+ }
+ }
+ }
+ };
+
+ class TSetShadedEvent: public TPrsManageEvent {
+ private:
+ bool myIsOn;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetShadedEvent(View3D_i* theView3D, ScalarMap_ptr thePrs, bool isOn):
+ TPrsManageEvent(theView3D, thePrs), myIsOn(isOn),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ if (VISU_ScalarMapAct* aScalarMapActor =
+ dynamic_cast<VISU_ScalarMapAct*>(anActor)) {
+ aScalarMapActor->SetShading(myIsOn);
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = "Corrupted actor";
+ }
+ } else {
+ myResult = myError;
+ }
+ }
+ };
+
+ class TSetOpacityEvent: public TPrsManageEvent {
+ private:
+ double myOpacity;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetOpacityEvent(View3D_i* theView3D, ScalarMap_ptr thePrs, double theOpacity):
+ TPrsManageEvent(theView3D, thePrs), myOpacity(theOpacity),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute() {
+ VISU::VISUType aType = myPrs->GetType();
+ if (aType == VISU::TVECTORS || aType == VISU::TSTREAMLINES) {
+ myResult = "Opacity is meaningless for this type of presentations.";
+ return;
+ }
+ if (VISU_Actor* anActor = GetMyActor()) {
+ anActor->SetOpacity((vtkFloatingPointType)myOpacity);
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = myError;
+ }
+ }
+ };
+
+ class TSetLineWidthEvent: public TPrsManageEvent {
+ private:
+ double myLineWidth;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetLineWidthEvent(View3D_i* theView3D, ScalarMap_ptr thePrs, double theLineWidth):
+ TPrsManageEvent(theView3D, thePrs), myLineWidth(theLineWidth),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute() {
+ if (myPrs->GetType() == VISU::TVECTORS) {
+ myResult = "Line Width is meaningless for Vectors presentation.";
+ return;
+ }
+ if (VISU_Actor* anActor = GetMyActor()) {
+ anActor->SetLineWidth((vtkFloatingPointType)myLineWidth);
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = myError;
+ }
+ }
+ };
+
+ PresentationType View3D_i::GetPresentationType(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetPrsTypeEvent(this,thePrs));
+ }
+ CORBA::Boolean View3D_i::IsShrinked(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetShrinkedEvent(this,thePrs));
+ }
+ CORBA::Boolean View3D_i::IsShaded(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetShadedEvent(this,thePrs));
+ }
+ CORBA::Double View3D_i::GetOpacity(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetOpacityEvent(this,thePrs));
+ }
+ CORBA::Double View3D_i::GetLineWidth(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetLineWidthEvent(this,thePrs));
+ }
+
+ char* View3D_i::SetPresentationType(ScalarMap_ptr thePrs, PresentationType thePrsType)
+ {
+ string aRet = ProcessEvent(new TSetPrsTypeEvent(this,thePrs,thePrsType));
+ return CORBA::string_dup(aRet.c_str());
+ }
+ char* View3D_i::SetShrinked(ScalarMap_ptr thePrs, CORBA::Boolean isShrinked)
+ {
+ string aRet = ProcessEvent(new TSetShrinkedEvent(this,thePrs,isShrinked));
+ return CORBA::string_dup(aRet.c_str());
+ }
+ char* View3D_i::SetShaded(ScalarMap_ptr thePrs, CORBA::Boolean isShaded)
+ {
+ string aRet = ProcessEvent(new TSetShadedEvent(this,thePrs,isShaded));
+ return CORBA::string_dup(aRet.c_str());
+ }
+ char* View3D_i::SetOpacity(ScalarMap_ptr thePrs, CORBA::Double theOpacity)
+ {
+ string aRet = ProcessEvent(new TSetOpacityEvent(this,thePrs,theOpacity));
+ return CORBA::string_dup(aRet.c_str());
+ }
+ char* View3D_i::SetLineWidth(ScalarMap_ptr thePrs, CORBA::Double theLineWidth)
+ {
+ string aRet = ProcessEvent(new TSetLineWidthEvent(this,thePrs,theLineWidth));
+ return CORBA::string_dup(aRet.c_str());
}
}
