-// VISU OBJECT : interactive object for VISU entities implementation
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
+// VISU OBJECT : interactive object for VISU entities implementation
// File : VISU_View_i.cc
// Author : Alexey PETROV
// Module : VISU
-
+//
#include "VISU_View_i.hh"
+#include "VISU_Tools.h"
#include "VISU_Gen_i.hh"
#include "VISU_Prs3d_i.hh"
#include "VISU_Table_i.hh"
+#include "VISU_PointMap3d_i.hh"
#include "VISU_ScalarMap_i.hh"
#include "VISU_ViewManager_i.hh"
-
-#include "VisuGUI_TableDlg.h"
+#include "VISU_TableDlg.h"
#include "VISU_Actor.h"
#include "VISU_ScalarMapAct.h"
+#include "VISU_PointMap3dActor.h"
+#include "VISU_DeformedGridPL.hxx"
-#include "SALOME_Event.hxx"
+#include "SALOME_Event.h"
#include "SUIT_ViewWindow.h"
#include "SUIT_ViewManager.h"
#include "SVTK_ViewWindow.h"
#include "SVTK_ViewModel.h"
+#include "VTKViewer_Algorithm.h"
#include "SPlot2d_ViewModel.h"
#include "Plot2d_ViewFrame.h"
#include "SalomeApp_Study.h"
#include <QtxWorkstack.h>
+#include <QtxWorkspace.h>
-#include <qworkspace.h>
-#include <qimage.h>
+#include <QWorkspace>
+#include <QImage>
#include <vtkCamera.h>
#include <vtkRenderer.h>
+#include <vtkActor.h>
using namespace std;
{
switch(myViewRepresentation){
case VISU::View::OBJECTBROWSER:
- myApplication->setWindowShown(SalomeApp_Application::WT_ObjectBrowser,myState);
+ myApplication->getWindow( SalomeApp_Application::WT_ObjectBrowser )->setVisible( myState );
break;
case VISU::View::PYTHON:
- myApplication->setWindowShown(SalomeApp_Application::WT_PyConsole,myState);
+ myApplication->getWindow( SalomeApp_Application::WT_PyConsole )->setVisible( myState );
break;
case VISU::View::MESSAGES:
- myApplication->setWindowShown(SalomeApp_Application::WT_LogWindow,myState);
+ myApplication->getWindow( SalomeApp_Application::WT_LogWindow )->setVisible( myState );
break;
- case VISU::View::VIEWER:{
+ case VISU::View::VIEWER:
+ {
ViewManagerList mgrs = myApplication->viewManagers();
ViewManagerList::const_iterator anIt = mgrs.begin(), aLast = mgrs.end();
for( ; anIt!=aLast; anIt++ )
{
- const QPtrVector<SUIT_ViewWindow>& views = (*anIt)->getViews();
+ const QVector<SUIT_ViewWindow*>& views = (*anIt)->getViews();
for( int i=0; i<views.count(); i++ )
views[i]->setShown( myState );
}
{
switch(myViewRepresentation){
case VISU::View::OBJECTBROWSER:
- myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_ObjectBrowser);
+ myResult = myApplication->dockWindow( SalomeApp_Application::WT_ObjectBrowser )->isVisible();
break;
case VISU::View::PYTHON:
- myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_PyConsole);
+ myResult = myApplication->dockWindow( SalomeApp_Application::WT_PyConsole )->isVisible();
break;
case VISU::View::MESSAGES:
- myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_LogWindow);
+ myResult = myApplication->dockWindow( SalomeApp_Application::WT_LogWindow )->isVisible();
break;
case VISU::View::VIEWER:{
ViewManagerList aViewManagerList = myApplication->viewManagers();
ViewManagerList::const_iterator anIt = aViewManagerList.begin();
for( ; anIt != aViewManagerList.end(); anIt++ )
{
- const QPtrVector<SUIT_ViewWindow>& views = (*anIt)->getViews();
+ const QVector<SUIT_ViewWindow*>& views = (*anIt)->getViews();
for( int i=0; i<views.count(); i++ ) {
- myResult = views[i]->isShown();
+ myResult = views[i]->isVisible();
return;
}
}
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
- Qt::Horizontal, QtxWorkstack::SPLIT_MOVE));
+ Qt::Horizontal, QtxWorkstack::SplitMove));
}
void
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
- Qt::Horizontal, QtxWorkstack::SPLIT_STAY));
+ Qt::Horizontal, QtxWorkstack::SplitStay));
}
void
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
- Qt::Vertical, QtxWorkstack::SPLIT_MOVE));
+ Qt::Vertical, QtxWorkstack::SplitMove));
}
void
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TSplitEvent(myApplication, aVW,
- Qt::Vertical, QtxWorkstack::SPLIT_STAY));
+ Qt::Vertical, QtxWorkstack::SplitStay));
}
void
void
Execute()
{
- if (QWidget* aParent = myVW->parentWidget(true)) {
+ if (QWidget* aParent = myVW->parentWidget()) {
QRect aQRect = aParent->frameGeometry();
(aQRect.*myAction)(mySize);
aParent->setGeometry(aQRect);
void
Execute()
{
- if(QWidget* aParent = myVW->parentWidget(true)){
+ if(QWidget* aParent = myVW->parentWidget()){
QRect aQRect = aParent->frameGeometry();
myResult = (aQRect.*myAction)();
}
class TAlignEvent: public TWorkspaceEvent
{
protected:
- Qt::AlignmentFlags myAligment;
+ Qt::AlignmentFlag myAligment;
public:
TAlignEvent(QWidget* theViewWindow,
QWidget* theWorkspace,
- Qt::AlignmentFlags theAligment):
+ Qt::AlignmentFlag theAligment):
TWorkspaceEvent(theViewWindow,theWorkspace),
myAligment(theAligment)
{}
void
Execute()
{
- if(QWidget* aParent = myVW->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget())
SUIT_Tools::alignWidget(aParent,myWorkspace,myAligment);
}
};
void
Execute()
{
- if(QWidget* aParent = myVW->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget())
aParent->move(int(myX*myWorkspace->width()),int(myY*myWorkspace->height()));
}
};
void
Execute()
{
- if(QWidget* aParent = myVW->parentWidget(true))
+ if(QWidget* aParent = myVW->parentWidget())
aParent->setGeometry(aParent->x(),
aParent->y(),
int(myX*myWorkspace->width()),
{
struct TEvent: public SALOME_Event
{
- QWidget* myWidget;
+ SVTK_ViewWindow* myVW;
SALOMEDS::Color myColor;
public:
- TEvent(QWidget* theWidget,
+ TEvent(SVTK_ViewWindow* theViewWindow,
const SALOMEDS::Color& theColor):
- myWidget(theWidget),
+ myVW(theViewWindow),
myColor(theColor)
{}
virtual void Execute(){
aColor[0] = int(255.0*myColor.R);
aColor[1] = int(255.0*myColor.G);
aColor[2] = int(255.0*myColor.B);
- myWidget->setBackgroundColor(QColor(aColor[0],aColor[1],aColor[2]));
+ QColor aNewColor (aColor[0],aColor[1],aColor[2]);
+ myVW->setBackgroundColor(aNewColor);
}
};
-
- SUIT_ViewWindow* aVW = GetViewWindow();
+
+ SVTK_ViewWindow* aVW = dynamic_cast<SVTK_ViewWindow*>(GetViewWindow());
if (aVW)
ProcessVoidEvent(new TEvent(aVW, theColor));
}
struct TBackgroundEvent: public SALOME_Event
{
- QWidget* myWidget;
+ SVTK_ViewWindow* myVW;
typedef SALOMEDS::Color TResult;
TResult myResult;
- TBackgroundEvent(QWidget* theWidget):
- myWidget(theWidget)
+ TBackgroundEvent(SVTK_ViewWindow* theViewWindow):
+ myVW(theViewWindow)
{}
virtual
void
Execute()
{
- const QColor& aColor = myWidget->backgroundColor();
- myResult.R = aColor.red()/255.0;
- myResult.G = aColor.green()/255.0;
- myResult.B = aColor.blue()/255.0;
+ vtkFloatingPointType backint[3];
+ GetRenderer(myVW)->GetBackground(backint);
+ myResult.R = backint[0];
+ myResult.G = backint[1];
+ myResult.B = backint[2];
}
};
View_i::
GetBackground()
{
- SUIT_ViewWindow* aVW = GetViewWindow();
+ SVTK_ViewWindow* aVW = dynamic_cast<SVTK_ViewWindow*>(GetViewWindow());
if (aVW)
return ProcessEvent(new TBackgroundEvent(aVW));
if (!img.isNull()) {
QString fileName (myFileName);
if (!fileName.isEmpty()) {
- QString fmt = SUIT_Tools::extension(fileName).upper();
+ QString fmt = SUIT_Tools::extension(fileName).toUpper();
if (fmt.isEmpty()) fmt = QString("BMP"); // default format
if (fmt == "JPG" ) fmt = "JPEG";
//QApplication::setOverrideCursor(Qt::waitCursor);
- img.save(fileName, fmt.latin1());
+ img.save(fileName, fmt.toLatin1().data());
myResult = true;
//QApplication::restoreOverrideCursor();
}
SUIT_ViewWindow* View_i::GetViewWindow()
{
if (myViewWindow) {
- QPtrVector<SUIT_ViewWindow> aViews = myViewManager->getViews();
- int aPos = aViews.find(myViewWindow);
+ QVector<SUIT_ViewWindow*> aViews = myViewManager->getViews();
+ int aPos = aViews.indexOf(myViewWindow);
if (aPos < 0)
myViewWindow = NULL;
}
ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::Repaint));
}
+ struct TCloseViewEvent: public SALOME_Event
+ {
+ SUIT_ViewWindow* myView;
+ TCloseViewEvent (SUIT_ViewWindow* theView):
+ myView(theView)
+ {}
+
+ virtual void Execute()
+ {
+ if ( myView ) myView->close();
+ }
+ };
+
void XYPlot_i::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();
+ ProcessVoidEvent(new TCloseViewEvent(GetViewWindow()));
+ QApplication::sendPostedEvents();
}
XYPlot_i::~XYPlot_i() {
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
- (aVW, &SUIT_ViewWindow::setCaption, QString(theTitle)));
+ (aVW, &SUIT_ViewWindow::setWindowTitle, QString(theTitle)));
}
char* XYPlot_i::GetTitle()
{
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
- return CORBA::string_dup(aVW->caption().latin1());
+ return CORBA::string_dup( aVW->windowTitle().toLatin1().data());
return CORBA::string_dup("");
}
char* XYPlot_i::GetSubTitle()
{
if (GetViewWindow())
- return CORBA::string_dup(myView->getTitle());
+ return CORBA::string_dup(myView->getTitle().toLatin1().data());
return CORBA::string_dup("");
}
char* XYPlot_i::GetXTitle()
{
if (GetViewWindow())
- return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::XTitle));
+ return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::XTitle).toLatin1().data());
return CORBA::string_dup("");
}
char* XYPlot_i::GetYTitle()
{
if (GetViewWindow())
- return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::YTitle));
+ return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::YTitle).toLatin1().data());
return CORBA::string_dup("");
}
virtual void Execute()
{
+ Qtx::VisibilityState state = (myDisplaing == eDisplay ||myDisplaing == eDisplayOnly) ?
+ Qtx::ShownState : Qtx::HiddenState;
// is it Curve ?
if (Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(myPrsObj).in())) {
- UpdatePlot2d(myView,myDisplaing,aCurve);
+ UpdatePlot2d(aCurve,myDisplaing,myView);
+ VISU::SetVisibilityState(aCurve->GetEntry(),state);
+ VISU::CurveVisibilityChanged(aCurve, myDisplaing , false, true, true);
}
// is it Container ?
if (Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(myPrsObj).in())) {
+ VISU::SetVisibilityState(aContainer->GetEntry(),state);
int nbCurves = aContainer->GetNbCurves();
for ( int i = 1; i <= nbCurves; i++ ) {
VISU::Curve_i* aCurve = aContainer->GetCurve( i );
if ( aCurve && aCurve->IsValid() ) {
- UpdatePlot2d(myView,myDisplaing,aCurve);
+ UpdatePlot2d(aCurve,myDisplaing,myView);
+ VISU::CurveVisibilityChanged(aCurve, myDisplaing , true, true, true);
}
}
myView->Repaint();
CORBA::Object_var childObject = VISU::ClientSObjectToObject(Iter->Value());
if (!CORBA::is_nil(childObject)) {
CORBA::Object_ptr aCurve = VISU::Curve::_narrow(childObject);
- if (!CORBA::is_nil(aCurve))
- UpdatePlot2d(myView, myDisplaing,
- dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCurve).in()));
+ if (!CORBA::is_nil(aCurve)) {
+ Curve_i* crv = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCurve).in());
+ UpdatePlot2d(crv, myDisplaing, myView);
+ VISU::CurveVisibilityChanged(crv, myDisplaing , true, false, true);
+ }
}
}
myView->Repaint();
+ VISU::SetVisibilityState(aTable->GetEntry(),state);
}
}
}
SalomeApp_Application* myApplication;
VISU::Table_i* myTable;
- typedef VisuGUI_TableDlg* TResult;
+ typedef VISU_TableDlg* TResult;
TResult myResult;
TCreateTableViewEvent (SalomeApp_Application* theApplication,
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(myTable->GetObjectEntry());
- if (aSObject) {
- myResult = new VisuGUI_TableDlg (myApplication->desktop(),
- aSObject,
- false,
- VisuGUI_TableDlg::ttAuto,
- Qt::Vertical);
- myResult->show();
- }
+ myResult = new VISU_TableDlg (myApplication->desktop(),
+ aCStudy,
+ myTable,
+ false,
+ VISU_TableDlg::ttAuto,
+ Qt::Vertical);
+ myResult->show();
}
}
}
void TableView_i::SetTitle (const char* theTitle)
{
- ProcessVoidEvent(new TVoidMemFun1ArgEvent<VisuGUI_TableDlg,const QString&,QString>
- (myView, &VisuGUI_TableDlg::setCaption, QString(theTitle)));
+ ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_TableDlg,const QString&,QString>
+ (myView, &VISU_TableDlg::setWindowTitle, QString(theTitle)));
}
char* TableView_i::GetTitle()
{
//jfa: may be need to be enclosed in SALOME_Event?
- return CORBA::string_dup(myView->caption().latin1());
+ return CORBA::string_dup(myView->windowTitle().toLatin1().data());
}
void TableView_i::Close()
{
SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>(myViewWindow);
vtkRenderer* aRenderer = aViewWindow->getRenderer();
- vtkActorCollection* anActors = aRenderer->GetActors();
+ VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
+ vtkActorCollection* anActors = aCopy.GetActors();
anActors->InitTraversal();
while (vtkActor *anAct = anActors->GetNextActor()) {
- if (VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(anAct)) {
+ if (VISU_ActorBase* anActor = dynamic_cast<VISU_ActorBase*>(anAct)) {
if (anActor->GetVisibility())
anActor->UpdateFromFactory();
}
string anEntry = anObj->GetID();
if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - anEntry = " << anEntry);
Storable::TRestoringMap aMap = Storable::GetStorableMap(anObj);
- if (Storable::FindValue(aMap, "myComment") == View3D_i::myComment) {
+ if (Storable::FindValue(aMap, "myComment") == View3D_i::myComment.c_str()) {
Restore(theViewManager->getActiveView(), aMap);
return true;
}
void View3D_i::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();
+ ProcessVoidEvent(new TCloseViewEvent(GetViewWindow()));
+ QApplication::sendPostedEvents();
}
-
+
View3D_i::~View3D_i()
{
if(MYDEBUG) MESSAGE("View3D_i::~View3D_i");
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
- (aVW,&SUIT_ViewWindow::setCaption,QString(theTitle)));
+ (aVW,&SUIT_ViewWindow::setWindowTitle,QString(theTitle)));
}
char* View3D_i::GetTitle()
{
SUIT_ViewWindow* aVW = GetViewWindow();
if (aVW)
- return CORBA::string_dup(aVW->caption().latin1());
+ return CORBA::string_dup(aVW->windowTitle().toLatin1().data());
return CORBA::string_dup("");
}
}
};
+ class TDisplayTableEvent: public SALOME_Event
+ {
+ SUIT_ViewWindow* myVW;
+ PointMap3d_i* myTable;
+ int myDisplaying;
+ public:
+ TDisplayTableEvent( SUIT_ViewWindow* theView,
+ PointMap3d_i* theTable,
+ int theDisplaying ) :
+ myVW (theView),
+ myTable (theTable),
+ myDisplaying (theDisplaying)
+ {}
+ virtual void Execute() {
+ SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>(myVW);
+ VISU_PointMap3dActor* anActor = myTable->CreateActor();
+ myTable->UpdateActor( anActor );
+ aViewWindow->AddActor( anActor );
+ }
+ };
+
void View3D_i::EraseAll()
{
if(MYDEBUG) MESSAGE("View3D_i::EraseAll");
if(MYDEBUG) MESSAGE("View3D_i::Display");
SUIT_ViewWindow* aVW = GetViewWindow();
CORBA::Object_ptr anObj = thePrsObj;
- Prs3d_i* aPrs =
dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
+ Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
if (aVW && aPrs)
ProcessVoidEvent(new TUpdateViewerEvent(aVW,aPrs,eDisplay));
+ else if (aVW && !aPrs) {
+ PointMap3d_i* aTable = dynamic_cast<PointMap3d_i*>(VISU::GetServant(anObj).in());
+ if (aTable)
+ ProcessVoidEvent(new TDisplayTableEvent(aVW, aTable, eDisplay));
+ }
}
void View3D_i::DisplayOnly (PrsObject_ptr thePrsObj)
Prs3d_i* aPrs = dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in());
if (aVW && aPrs)
ProcessVoidEvent(new TUpdateViewerEvent(aVW,aPrs,eDisplayOnly));
+ else if (aVW && !aPrs) {
+ PointMap3d_i* aTable = dynamic_cast<PointMap3d_i*>(VISU::GetServant(anObj).in());
+ if (aTable)
+ ProcessVoidEvent(new TDisplayTableEvent(aVW, aTable, eDisplayOnly));
+ }
}
void View3D_i::FitAll()
myResult("Unknown error occured")
{}
virtual void Execute() {
+ VISU::VISUType aType = myPrs->GetType();
switch (myPrsType) {
case VISU::INSIDEFRAME:
{
- VISU::VISUType aType = myPrs->GetType();
if (aType != VISU::TSCALARMAP &&
aType != VISU::TDEFORMEDSHAPE &&
- aType != VISU::TSCALARMAPONDEFORMEDSHAPE) {
+ aType != VISU::TSCALARMAPONDEFORMEDSHAPE &&
+ aType != VISU::TDEFORMEDSHAPEANDSCALARMAP) {
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;
+ {
+ if (aType != VISU::TSCALARMAP &&
+ aType != VISU::TDEFORMEDSHAPE &&
+ aType != VISU::TSCALARMAPONDEFORMEDSHAPE &&
+ aType != VISU::TDEFORMEDSHAPEANDSCALARMAP &&
+ aType != VISU::TCUTPLANES &&
+ aType != VISU::TISOSURFACES &&
+ aType != VISU::TPLOT3D) {
+ myResult = "Surfaceframe representation is not available for this type of presentations.";
+ return;
+ }
+ }
+ break;
case VISU::SHRINK:
myResult = "Use SetShrinked() method to shrink/unshrink presentation.";
return;
}
};
+ class TSetQuadratic2DPresentationTypeEvent: public TPrsManageEvent {
+ private:
+ Quadratic2DPresentationType myPrsType;
+ public:
+ typedef string TResult;
+ TResult myResult;
+ TSetQuadratic2DPresentationTypeEvent(View3D_i* theView3D,
+ ScalarMap_ptr thePrs,
+ Quadratic2DPresentationType theType):
+ TPrsManageEvent(theView3D, thePrs), myPrsType(theType),
+ myResult("Unknown error occured")
+ {}
+ virtual void Execute()
+ {
+ VISU::VISUType aType = myPrs->GetType();
+ if (aType != VISU::TSCALARMAP &&
+ aType != VISU::TDEFORMEDSHAPE &&
+ aType != VISU::TSCALARMAPONDEFORMEDSHAPE &&
+ aType != VISU::TDEFORMEDSHAPEANDSCALARMAP) {
+ myResult = "2D Quadratic element representation is not available for this type of presentations.";
+ return;
+ }
+ if (VISU_Actor* anActor = GetMyActor()) {
+ if(myPrsType == VISU::LINES)
+ anActor->SetQuadratic2DRepresentation(VISU_Actor::eLines);
+ else if(myPrsType == VISU::ARCS)
+ anActor->SetQuadratic2DRepresentation(VISU_Actor::eArcs);
+
+ SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(myView3D->GetViewWindow());
+ vw->Repaint();
+ myResult = "";
+ } else {
+ myResult = myError;
+ }
+ }
+ };
+
+ class TGetQuadratic2DPresentationTypeEvent: public TPrsManageEvent {
+ public:
+ typedef VISU::Quadratic2DPresentationType TResult;
+ TResult myResult;
+ TGetQuadratic2DPresentationTypeEvent(View3D_i* theView3D, ScalarMap_ptr thePrs):
+ TPrsManageEvent(theView3D, thePrs), myResult(VISU::LINES) {}
+ virtual void Execute() {
+ if (VISU_Actor* anActor = GetMyActor()) {
+ if(anActor->GetQuadratic2DRepresentation() == VISU_Actor::eLines)
+ myResult = VISU::LINES;
+ else if(anActor->GetQuadratic2DRepresentation() == VISU_Actor::eArcs)
+ myResult = VISU::ARCS;
+ }
+ }
+ };
+
PresentationType View3D_i::GetPresentationType(ScalarMap_ptr thePrs)
{
return ProcessEvent(new TGetPrsTypeEvent(this,thePrs));
return ProcessEvent(new TGetLineWidthEvent(this,thePrs));
}
+ Quadratic2DPresentationType View3D_i::GetQuadratic2DPresentationType(ScalarMap_ptr thePrs)
+ {
+ return ProcessEvent(new TGetQuadratic2DPresentationTypeEvent(this,thePrs));
+ }
+
char* View3D_i::SetPresentationType(ScalarMap_ptr thePrs, PresentationType thePrsType)
{
string aRet = ProcessEvent(new TSetPrsTypeEvent(this,thePrs,thePrsType));
string aRet = ProcessEvent(new TSetLineWidthEvent(this,thePrs,theLineWidth));
return CORBA::string_dup(aRet.c_str());
}
+
+ char* View3D_i::SetQuadratic2DPresentationType(ScalarMap_ptr thePrs, Quadratic2DPresentationType theType)
+ {
+ string aRet = ProcessEvent(new TSetQuadratic2DPresentationTypeEvent(this,thePrs,theType));
+ return CORBA::string_dup(aRet.c_str());
+ }
}
+
+
