mouse buttons pressed simultaneously.</center>
<hr>
+\image html image111.png
+\n <center><b>Zooming style switch</b> - allows to switch between standard
+(zooming at the center of the view) and advanced (zooming at the current cursor
+position) zooming styles.</center>
+<hr>
+
\image html image88.png
\n <center><b>Show/Hide Trihedron</b> - shows or hides coordinate axes.</center>
<hr>
with the left button, translation with the right and zoom with both
pressed in the same time.</li>
</ul>
+<li><b>Zooming mode</b> - this option allows to choose a zooming mode.</li>
+<ul>
+<li><b>Relative to the view's center</b> - allows to zoom the view
+relatively to its center.</li>
+<li><b>Relative to the cursor</b> - allows to zoom the view
+relatively to the current cursor position..</li>
+</ul>
<li><b>[+]/[-] Speed Increment</b> - defines the number of units by
which the speed increases or respectively decreases after pressing [+]
or [-] keyboard buttons.</li>
mouse buttons pressed simultaneously.</center>
<hr>
+\image html image111.png
+\n <center><b>Zooming style switch</b> - allows to switch between standard
+(zooming at the center of the view) and advanced (zooming at the current cursor
+position) zooming styles. The second mode is available only for parallel
+(non-perspective) view's mode.</center>
+<hr>
+
\image html image88.png
\n <center><b>Show/Hide Trihedron</b> - shows or hides coordinate axes.</center>
<hr>
#include "LightApp_OBSelector.h"
#include "LightApp_SelectionMgr.h"
#include "LightApp_DataObject.h"
+#include "LightApp_WgViewModel.h"
#include <SALOME_Event.h>
#include <SALOME_ListIO.hxx>
#endif
+#include <Standard_Version.hxx>
+
+#ifdef OCC_VERSION_SERVICEPACK
+#define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8 | OCC_VERSION_SERVICEPACK)
+#else
+#define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8)
+#endif
+
#define ToolBarMarker 0
#define DockWidgetMarker 1
v = resMgr->integerValue( "OCCViewer", "iso_number_v", v );
vm->setIsos( u, v );
vm->setInteractionStyle( resMgr->integerValue( "OCCViewer", "navigation_mode", vm->interactionStyle() ) );
+ vm->setZoomingStyle( resMgr->integerValue( "OCCViewer", "zooming_mode", vm->zoomingStyle() ) );
viewMgr->setViewModel( vm );// custom view model, which extends SALOME_View interface
new LightApp_OCCSelector( (OCCViewer_Viewer*)viewMgr->getViewModel(), mySelMgr );
}
resMgr->booleanValue( "VTKViewer", "relative_size", vm->trihedronRelative() ) );
vm->setStaticTrihedronVisible( resMgr->booleanValue( "VTKViewer", "show_static_trihedron", vm->isStaticTrihedronVisible() ) );
vm->setInteractionStyle( resMgr->integerValue( "VTKViewer", "navigation_mode", vm->interactionStyle() ) );
+ vm->setZoomingStyle( resMgr->integerValue( "VTKViewer", "zooming_mode", vm->zoomingStyle() ) );
vm->setIncrementalSpeed( resMgr->integerValue( "VTKViewer", "speed_value", vm->incrementalSpeed() ),
resMgr->integerValue( "VTKViewer", "speed_mode", vm->incrementalSpeedMode() ) );
vm->setSpacemouseButtons( resMgr->integerValue( "VTKViewer", "spacemouse_func1_btn", vm->spacemouseBtn(1) ),
return viewMgr;
}
+SUIT_ViewManager* LightApp_Application::createViewManager( const QString& vmType, QWidget* w )
+{
+ SUIT_ViewManager* vm = new SUIT_ViewManager( activeStudy(),
+ desktop(),
+ new LightApp_WgViewModel( vmType, w ) );
+ vm->setTitle( QString( "%1: %M - viewer %V" ).arg( vmType ) );
+
+ addViewManager( vm );
+ SUIT_ViewWindow* vw = vm->createViewWindow();
+ if ( vw && desktop() )
+ vw->resize( (int)( desktop()->width() * 0.6 ), (int)( desktop()->height() * 0.6 ) );
+
+ if ( !vmType.isEmpty() && !myUserWmTypes.contains( vmType ) )
+ myUserWmTypes << vmType;
+
+ return vm;
+}
+
/*!
SLOT: Removes view manager from application
*/
pref->setItemProperty( "strings", aStyleModeList, occStyleMode );
pref->setItemProperty( "indexes", aModeIndexesList, occStyleMode );
+#if OCC_VERSION_LARGE > 0x06030010 // available only with OCC-6.3-sp11 and higher version
+ int occZoomingStyleMode = pref->addPreference( tr( "PREF_ZOOMING" ), occGroup,
+ LightApp_Preferences::Selector, "OCCViewer", "zooming_mode" );
+ QStringList anOCCZoomingStyleModeList;
+ anOCCZoomingStyleModeList.append( tr("PREF_ZOOMING_AT_CENTER") );
+ anOCCZoomingStyleModeList.append( tr("PREF_ZOOMING_AT_CURSOR") );
+
+ pref->setItemProperty( "strings", anOCCZoomingStyleModeList, occZoomingStyleMode );
+ pref->setItemProperty( "indexes", aModeIndexesList, occZoomingStyleMode );
+#endif
+
// VTK Viewer
int vtkGen = pref->addPreference( "", vtkGroup, LightApp_Preferences::Frame );
pref->setItemProperty( "columns", 2, vtkGen );
pref->setItemProperty( "strings", aStyleModeList, vtkStyleMode );
pref->setItemProperty( "indexes", aModeIndexesList, vtkStyleMode );
- pref->addPreference( "", vtkGroup, LightApp_Preferences::Space );
+ int vtkZoomingStyleMode = pref->addPreference( tr( "PREF_ZOOMING" ), vtkGen,
+ LightApp_Preferences::Selector, "VTKViewer", "zooming_mode" );
+
+ QStringList aVTKZoomingStyleModeList;
+ aVTKZoomingStyleModeList.append( tr("PREF_ZOOMING_AT_CENTER") );
+ aVTKZoomingStyleModeList.append( tr("PREF_ZOOMING_AT_CURSOR") );
+
+ pref->setItemProperty( "strings", aVTKZoomingStyleModeList, vtkZoomingStyleMode );
+ pref->setItemProperty( "indexes", aModeIndexesList, vtkZoomingStyleMode );
int vtkSpeed = pref->addPreference( tr( "PREF_INCREMENTAL_SPEED" ), vtkGen,
LightApp_Preferences::IntSpin, "VTKViewer", "speed_value" );
}
#endif
+#ifndef DISABLE_OCCVIEWER
+ if ( sec == QString( "OCCViewer" ) && param == QString( "zooming_mode" ) )
+ {
+ int mode = resMgr->integerValue( "OCCViewer", "zooming_mode", 0 );
+ QList<SUIT_ViewManager*> lst;
+ viewManagers( OCCViewer_Viewer::Type(), lst );
+ QListIterator<SUIT_ViewManager*> it( lst );
+ while ( it.hasNext() )
+ {
+ SUIT_ViewModel* vm = it.next()->getViewModel();
+ if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
+ continue;
+
+ OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
+ occVM->setZoomingStyle( mode );
+ }
+ }
+#endif
+
#ifndef DISABLE_VTKVIEWER
if ( sec == QString( "VTKViewer" ) && (param == QString( "trihedron_size" ) || param == QString( "relative_size" )) )
{
}
#endif
+#ifndef DISABLE_VTKVIEWER
+ if ( sec == QString( "VTKViewer" ) && param == QString( "zooming_mode" ) )
+ {
+ int mode = resMgr->integerValue( "VTKViewer", "zooming_mode", 0 );
+ QList<SUIT_ViewManager*> lst;
+#ifndef DISABLE_SALOMEOBJECT
+ viewManagers( SVTK_Viewer::Type(), lst );
+ QListIterator<SUIT_ViewManager*> it( lst );
+ while ( it.hasNext() )
+ {
+ SUIT_ViewModel* vm = it.next()->getViewModel();
+ if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
+ continue;
+
+ SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
+ if( vtkVM ) vtkVM->setZoomingStyle( mode );
+ }
+#endif
+ }
+#endif
+
#ifndef DISABLE_VTKVIEWER
if ( sec == QString( "VTKViewer" ) && param == QString( "show_static_trihedron" ) )
{
QStringList LightApp_Application::viewManagersTypes() const
{
QStringList aTypesList;
+ aTypesList += myUserWmTypes;
#ifndef DISABLE_GLVIEWER
aTypesList<<GLViewer_Viewer::Type();
#endif
#include <CAM_Application.h>
#include <QPointer>
+#include <QStringList>
class LogWindow;
#ifndef DISABLE_PYCONSOLE
virtual void addViewManager( SUIT_ViewManager* );
virtual void removeViewManager( SUIT_ViewManager* );
virtual SUIT_ViewManager* createViewManager( const QString& vmType );
+ virtual SUIT_ViewManager* createViewManager( const QString& vmType, QWidget* w );
QWidget* getWindow( const int, const int = -1 );
QWidget* dockWindow( const int ) const;
static LightApp_Preferences* _prefs_;
static int lastStudyId;
+ QStringList myUserWmTypes;
};
#ifdef WIN32
--- /dev/null
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// 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
+//
+// File : LightApp_LightApp_WgViewModel.cxx
+// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
+
+#include "LightApp_WgViewModel.h"
+#include "SUIT_ViewWindow.h"
+
+LightApp_WgViewModel::LightApp_WgViewModel( const QString& type, QWidget* w )
+ : SUIT_ViewModel(),
+ myType( type ),
+ myWidget( w ),
+ myCreated( false )
+{
+}
+
+LightApp_WgViewModel::~LightApp_WgViewModel()
+{
+}
+
+SUIT_ViewWindow* LightApp_WgViewModel::createView( SUIT_Desktop* d )
+{
+ SUIT_ViewWindow* vw = 0;
+ if ( !myCreated ) {
+ vw = new SUIT_ViewWindow( d );
+ vw->setCentralWidget( myWidget );
+ myCreated = true;
+ vw->setClosable( false );///////////////////
+ }
+ return vw;
+}
+
+QString LightApp_WgViewModel::getType() const
+{
+ return myType;
+}
--- /dev/null
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// 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
+//
+// File : LightApp_LightApp_WgViewModel.h
+// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
+
+#ifndef LIGHTAPP_WGVIEWMODEL_H
+#define LIGHTAPP_WGVIEWMODEL_H
+
+#include "SUIT_ViewModel.h"
+#include "SUIT_ViewManager.h"
+
+class LightApp_WgViewModel : public SUIT_ViewModel
+{
+ Q_OBJECT
+
+public:
+ LightApp_WgViewModel( const QString& type, QWidget* w );
+ virtual ~LightApp_WgViewModel();
+
+ virtual SUIT_ViewWindow* createView( SUIT_Desktop* d );
+ virtual QString getType() const;
+
+private:
+ QString myType;
+ QWidget* myWidget;
+ bool myCreated;
+};
+#endif // LIGHTAPP_WGVIEWMODEL_H
LightApp_SwitchOp.h \
LightApp_Preferences.h \
LightApp_PreferencesDlg.h \
- LightApp_UpdateFlags.h
+ LightApp_UpdateFlags.h \
+ LightApp_WgViewModel.h
if ENABLE_PYCONSOLE
salomeinclude_HEADERS += LightApp_PyInterp.h
LightApp_Study.cxx \
LightApp_SwitchOp.cxx \
LightApp_Preferences.cxx \
- LightApp_PreferencesDlg.cxx
+ LightApp_PreferencesDlg.cxx \
+ LightApp_WgViewModel.cxx
if ENABLE_PYCONSOLE
dist_libLightApp_la_SOURCES += LightApp_PyInterp.cxx
LightApp_Study_moc.cxx \
LightApp_SwitchOp_moc.cxx \
LightApp_Preferences_moc.cxx \
- LightApp_PreferencesDlg_moc.cxx
+ LightApp_PreferencesDlg_moc.cxx \
+ LightApp_WgViewModel_moc.cxx
if ENABLE_VTKVIEWER
if ENABLE_SALOMEOBJECT
<parameter name="iso_number_v" value="1" />
<parameter name="trihedron_size" value="100" />
<parameter name="navigation_mode" value="0" />
+ <parameter name="zooming_mode" value="0" />
</section>
<section name="VTKViewer" >
<!-- VTK viewer preferences -->
<parameter name="relative_size" value="true" />
<parameter name="use_advanced_selection_algorithm" value="true" />
<parameter name="navigation_mode" value="0" />
+ <parameter name="zooming_mode" value="0" />
<parameter name="speed_value" value="10" />
<parameter name="speed_mode" value="0" />
<parameter name="show_static_trihedron" value="true" />
<source>PREF_KEYFREE_STYLE</source>
<translation>Keyboard free style</translation>
</message>
+ <message>
+ <source>PREF_ZOOMING</source>
+ <translation>Zooming:</translation>
+ </message>
+ <message>
+ <source>PREF_ZOOMING_AT_CENTER</source>
+ <translation>Relative to the view's center</translation>
+ </message>
+ <message>
+ <source>PREF_ZOOMING_AT_CURSOR</source>
+ <translation>Relative to the cursor</translation>
+ </message>
<message>
<source>PREF_INCREMENTAL_SPEED</source>
<translation>Speed increment:</translation>
resources/occ_view_top.png \
resources/occ_view_triedre.png \
resources/occ_view_zoom.png \
- resources/occ_view_rotation_point.png
+ resources/occ_view_rotation_point.png \
+ resources/occ_view_style_switch.png \
+ resources/occ_view_zooming_style_switch.png
nodist_salomeres_DATA = \
OCCViewer_images.qm \
// set interaction style to standard
myInteractionStyle = 0;
+ // set zooming style to standard
+ myZoomingStyle = 0;
+
// selection
mySelectionEnabled = true;
myMultiSelectionEnabled = true;
view->initLayout();
view->initSketchers();
view->setInteractionStyle( interactionStyle() );
+ view->setZoomingStyle( zoomingStyle() );
OCCViewer_ViewPort3d* vp3d = view->getViewPort();
if ( vp3d )
}
}
+/*!
+ \return zooming style
+*/
+int OCCViewer_Viewer::zoomingStyle() const
+{
+ return myZoomingStyle;
+}
+
+/*!
+ Sets zooming style: 0 - standard, 1 - advanced (at cursor)
+ \param theStyle - new zooming style
+*/
+void OCCViewer_Viewer::setZoomingStyle( const int theStyle )
+{
+ myZoomingStyle = theStyle;
+ //!! To be done for view windows
+ if ( !myViewManager )
+ return;
+
+ QVector<SUIT_ViewWindow*> wins = myViewManager->getViews();
+ for ( int i = 0; i < (int)wins.count(); i++ )
+ {
+ OCCViewer_ViewWindow* win = ::qobject_cast<OCCViewer_ViewWindow*>( wins.at( i ) );
+ if ( win )
+ win->setZoomingStyle( theStyle );
+ }
+}
+
/*!
Sets selection enabled status
\param isEnabled - new status
int interactionStyle() const;
void setInteractionStyle( const int );
+ int zoomingStyle() const;
+ void setZoomingStyle( const int );
+
void enableSelection(bool isEnabled);
bool isSelectionEnabled() const { return mySelectionEnabled; }
viewAspectList myViewAspects;
int myInteractionStyle;
+ int myZoomingStyle;
bool mySelectionEnabled;
bool myMultiSelectionEnabled;
static int sy = 0;
static Standard_Boolean zRotation = Standard_False;
+#include <Standard_Version.hxx>
+
+#ifdef OCC_VERSION_SERVICEPACK
+#define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8 | OCC_VERSION_SERVICEPACK)
+#else
+#define OCC_VERSION_LARGE (OCC_VERSION_MAJOR << 24 | OCC_VERSION_MINOR << 16 | OCC_VERSION_MAINTENANCE << 8)
+#endif
+
/*!
Constructor
*/
myScale( 1.0 ),
myDegenerated( true ),
myAnimate( false ),
- myBusy( true )
+ myBusy( true ),
+ myIsAdvancedZoomingEnabled( false )
{
selectVisualId();
activeView()->WindowFit( rect.left(), rect.top(), rect.right(), rect.bottom() );
}
+/*!
+ Inits 'zoom' transformation. [ protected ]
+*/
+void OCCViewer_ViewPort3d::startZoomAtPoint( int x, int y )
+{
+#if OCC_VERSION_LARGE > 0x06030010 // available only with OCC-6.3-sp11 and higher version
+ if ( !activeView().IsNull() && isAdvancedZoomingEnabled() )
+ activeView()->StartZoomAtPoint( x, y );
+#endif
+}
+
/*!
Called at 'zoom' transformation. [ virtual protected ]
*/
// as OCCT respects a sign of only dx,
// but we want both signes to be taken into account
//activeView()->Zoom( x0, y0, x, y );
- activeView()->Zoom( x0 + y0, 0, x + y, 0 );
+#if OCC_VERSION_LARGE > 0x06030010 // available only with OCC-6.3-sp11 and higher version
+ if ( isAdvancedZoomingEnabled() )
+ activeView()->ZoomAtPoint( x0, y0, x, y );
+ else
+#endif
+ activeView()->Zoom( x0 + y0, 0, x + y, 0 );
}
}
virtual void pan( int , int );
virtual void setCenter( int , int );
virtual void fitRect( const QRect& );
+ virtual void startZoomAtPoint( int, int );
virtual void zoom( int, int, int, int );
virtual void fitAll( bool keepScale = false, bool withZ = true, bool upd = true );
virtual void endRotation();
bool isBusy() {return myBusy;} // check that View Port is fully initialized
+ void setAdvancedZoomingEnabled( const bool theState ) { myIsAdvancedZoomingEnabled = theState; }
+ bool isAdvancedZoomingEnabled() const { return myIsAdvancedZoomingEnabled; }
+
protected:
// EVENTS
virtual void paintEvent( QPaintEvent* );
bool myAnimate;
bool myBusy;
double myScale;
+ bool myIsAdvancedZoomingEnabled;
};
#ifdef WIN32
break;
case ZOOMVIEW:
- if ( theEvent->button() == Qt::LeftButton )
+ if ( theEvent->button() == Qt::LeftButton ) {
+ myViewPort->startZoomAtPoint( myStartX, myStartY );
emit vpTransformationStarted ( ZOOMVIEW );
+ }
break;
case PANVIEW:
- if ( aSwitchToZoom )
+ if ( aSwitchToZoom ) {
+ myViewPort->startZoomAtPoint( myStartX, myStartY );
activateZoom();
+ }
else if ( theEvent->button() == Qt::LeftButton )
emit vpTransformationStarted ( PANVIEW );
break;
case ROTATE:
- if ( aSwitchToZoom )
+ if ( aSwitchToZoom ) {
+ myViewPort->startZoomAtPoint( myStartX, myStartY );
activateZoom();
+ }
else if ( theEvent->button() == Qt::LeftButton ) {
myViewPort->startRotation(myStartX, myStartY, myCurrPointType, mySelectedPoint);
emit vpTransformationStarted ( ROTATE );
/* Try to activate a transformation */
switch ( getButtonState(theEvent, anInteractionStyle) ) {
case ZOOMVIEW:
- activateZoom();
+ myViewPort->startZoomAtPoint( myStartX, myStartY );
+ activateZoom();
break;
case PANVIEW:
activatePanning();
toolMgr()->registerAction( aAction, AmbientId );
// Switch between interaction styles
- aAction = new QtxAction(tr("MNU_STYLE_SWITCH"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_SVTK_STYLE_SWITCH" ) ),
+ aAction = new QtxAction(tr("MNU_STYLE_SWITCH"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_STYLE_SWITCH" ) ),
tr( "MNU_STYLE_SWITCH" ), 0, this);
aAction->setStatusTip(tr("DSC_STYLE_SWITCH"));
aAction->setCheckable(true);
connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchInteractionStyle(bool)));
toolMgr()->registerAction( aAction, SwitchInteractionStyleId );
+
+ // Switch between zooming styles
+ aAction = new QtxAction(tr("MNU_ZOOMING_STYLE_SWITCH"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_ZOOMING_STYLE_SWITCH" ) ),
+ tr( "MNU_ZOOMING_STYLE_SWITCH" ), 0, this);
+ aAction->setStatusTip(tr("DSC_ZOOMING_STYLE_SWITCH"));
+ aAction->setCheckable(true);
+ connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchZoomingStyle(bool)));
+ toolMgr()->registerAction( aAction, SwitchZoomingStyleId );
}
/*!
toolMgr()->append( DumpId, tid );
toolMgr()->append( SwitchInteractionStyleId, tid );
+#if OCC_VERSION_LARGE > 0x06030010 // available only with OCC-6.3-sp11 and higher version
+ toolMgr()->append( SwitchZoomingStyleId, tid );
+#endif
if( myModel->trihedronActivated() )
toolMgr()->append( TrihedronShowId, tid );
a->setChecked( on );
}
+/*!
+ \brief Toogles advanced zooming style (relatively to the cursor position) on/off
+*/
+void OCCViewer_ViewWindow::onSwitchZoomingStyle( bool on )
+{
+ myViewPort->setAdvancedZoomingEnabled( on );
+
+ // update action state if method is called outside
+ QtxAction* a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchZoomingStyleId ) );
+ if ( a->isChecked() != on )
+ a->setChecked( on );
+}
+
/*!
\brief Get current interaction style
\return interaction style
onSwitchInteractionStyle( theStyle == (int)SUIT_ViewModel::KEY_FREE );
}
+/*!
+ \brief Get current zooming style
+ \return zooming style
+*/
+int OCCViewer_ViewWindow::zoomingStyle() const
+{
+ return myViewPort->isAdvancedZoomingEnabled() ? 1 : 0;
+}
+
+/*!
+ \brief Set current zooming style
+ \param theStyle zooming style
+*/
+void OCCViewer_ViewWindow::setZoomingStyle( const int theStyle )
+{
+ onSwitchZoomingStyle( theStyle == 1 );
+}
+
/*!
\brief Dump view window contents to the pixmap.
\return pixmap containing all scene rendered in the window
enum { DumpId, FitAllId, FitRectId, ZoomId, PanId, GlobalPanId,
ChangeRotationPointId, RotationId,
FrontId, BackId, TopId, BottomId, LeftId, RightId, ResetId, CloneId, ClippingId, MemId, RestoreId,
- TrihedronShowId, AxialScaleId, GraduatedAxesId, AmbientId, SwitchInteractionStyleId };
+ TrihedronShowId, AxialScaleId, GraduatedAxesId, AmbientId, SwitchInteractionStyleId, SwitchZoomingStyleId };
enum OperationType{ NOTHING, PANVIEW, ZOOMVIEW, ROTATE,
PANGLOBAL, WINDOWFIT, FITALLVIEW, RESETVIEW,
int interactionStyle() const;
void setInteractionStyle( const int );
+ int zoomingStyle() const;
+ void setZoomingStyle( const int );
+
void setTransformEnabled( const OperationType, const bool );
bool transformEnabled( const OperationType ) const;
void onTrihedronShow();
void setRestoreFlag();
void onSwitchInteractionStyle( bool on );
+ void onSwitchZoomingStyle( bool on );
void activateSetRotationGravity();
void activateSetRotationSelected( double theX, double theY, double theZ );
<source>ICON_OCCVIEWER_STYLE_SWITCH</source>
<translation>occ_view_style_switch.png</translation>
</message>
+ <message>
+ <source>ICON_OCCVIEWER_ZOOMING_STYLE_SWITCH</source>
+ <translation>occ_view_zooming_style_switch.png</translation>
+ </message>
</context>
</TS>
<source>MNU_STYLE_SWITCH</source>
<translation>Interaction style switch</translation>
</message>
+ <message>
+ <source>DSC_ZOOMING_STYLE_SWITCH</source>
+ <translation>Zooming style switch</translation>
+ </message>
+ <message>
+ <source>MNU_ZOOMING_STYLE_SWITCH</source>
+ <translation>Zooming style switch</translation>
+ </message>
<message>
<source>OCC_IMAGE_FILES</source>
<translation>Images Files (*.bmp *.png *.jpg *.jpeg)</translation>
SALOME_PYQT_ModuleLight::onViewClosed( pview );
}
+/*!
+ \brief Signal handler tryClose(SUIT_ViewWindow*) of a view
+ \param pview view user tries to close
+*/
+void SALOME_PYQT_Module::onViewTryClose( SUIT_ViewWindow* pview )
+{
+ SALOME_PYQT_ModuleLight::onViewTryClose( pview );
+}
+
/*!
\breif Process application preferences changing.
void onGUIEvent();
void onActiveViewChanged( SUIT_ViewWindow* );
void onViewClosed( SUIT_ViewWindow* );
+ void onViewTryClose( SUIT_ViewWindow* );
void onViewCloned( SUIT_ViewWindow* );
protected:
PyLockWrapper aLock = myInterp->GetLockWrapper();
// ... (the Python module is already imported)
// ... finally call Python module's initialize() method
- if ( PyObject_HasAttrString( myModule, "initialize" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"initialize" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"initialize", (char*)"" ) );
if ( !res ) {
PyErr_Print();
myWindowsMap.insert( LightApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
myWindowsMap.insert( LightApp_Application::WT_LogWindow, Qt::BottomDockWidgetArea );
- if ( PyObject_HasAttrString( myModule , "windows" ) ) {
+ if ( PyObject_HasAttrString( myModule , (char*)"windows" ) ) {
PyObjWrapper res1( PyObject_CallMethod( myModule, (char*)"windows", (char*)"" ) );
if ( !res1 ) {
PyErr_Print();
// get compatible view windows types from the Python module
// by calling views() method
- if ( PyObject_HasAttrString( myModule , "views" ) ) {
+ if ( PyObject_HasAttrString( myModule , (char*)"views" ) ) {
PyObjWrapper res2( PyObject_CallMethod( myModule, (char*)"views", (char*)"" ) );
if ( !res2 ) {
PyErr_Print();
PyLockWrapper aLock = myInterp->GetLockWrapper();
// call Python module's activate() method (for the new modules)
- if ( PyObject_HasAttrString( myModule , "activate" ) ) {
+ if ( PyObject_HasAttrString( myModule , (char*)"activate" ) ) {
PyObject* res1 = PyObject_CallMethod( myModule, (char*)"activate", (char*)"" );
if ( !res1 || !PyBool_Check( res1 ) ) {
PyErr_Print();
if ( IsCallOldMethods ) {
// call Python module's setSettings() method (obsolete)
- if ( PyObject_HasAttrString( myModule , "setSettings" ) ) {
+ if ( PyObject_HasAttrString( myModule , (char*)"setSettings" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"setSettings", (char*)"" ) );
if( !res ) {
PyErr_Print();
return;
}
// then call Python module's deactivate() method
- if ( PyObject_HasAttrString( myModule , "deactivate" ) ) {
+ if ( PyObject_HasAttrString( myModule , (char*)"deactivate" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"deactivate", (char*)"" ) );
if( !res ) {
PyErr_Print();
PyLockWrapper aLock = myInterp->GetLockWrapper();
// call Python module's activeStudyChanged() method
- if ( PyObject_HasAttrString( myModule, "activeStudyChanged" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"activeStudyChanged" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"activeStudyChanged", (char*)"i", aStudyId ) );
if( !res ) {
PyErr_Print();
QString aContext( "" ), aObject( "" ), aParent( theContext );
- if ( IsCallOldMethods && PyObject_HasAttrString( myModule, "definePopup" ) ) {
+ if ( IsCallOldMethods && PyObject_HasAttrString( myModule, (char*)"definePopup" ) ) {
// call definePopup() Python module's function
// this is obsolete function, used only for compatibility reasons
PyObjWrapper res( PyObject_CallMethod( myModule,
#endif
// then call Python module's createPopupMenu() method (for new modules)
- if ( PyObject_HasAttrString( myModule, "createPopupMenu" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"createPopupMenu" ) ) {
PyObjWrapper res1( PyObject_CallMethod( myModule,
(char*)"createPopupMenu",
(char*)"Os",
}
}
- if ( IsCallOldMethods && PyObject_HasAttrString( myModule, "customPopup" ) ) {
+ if ( IsCallOldMethods && PyObject_HasAttrString( myModule, (char*)"customPopup" ) ) {
// call customPopup() Python module's function
// this is obsolete function, used only for compatibility reasons
PyObjWrapper res2( PyObject_CallMethod( myModule,
if ( !myInterp || !myModule )
return;
- if ( PyObject_HasAttrString( myModule, "OnGUIEvent" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"OnGUIEvent" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"OnGUIEvent", (char*)"i", theId ) );
if( !res ) {
PyErr_Print();
// might be called during the module intialization process
myInitModule = this;
- if ( PyObject_HasAttrString( myModule, "createPreferences" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"createPreferences" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"createPreferences", (char*)"" ) );
if( !res ) {
PyErr_Print();
PyObjWrapper pyws( sipBuildResult( 0, "D", aWorkspace, sipType_QWidget , NULL) );
#endif
// ... and finally call Python module's setWorkspace() method (obsolete)
- if ( PyObject_HasAttrString( myModule, "setWorkSpace" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"setWorkSpace" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"setWorkSpace", (char*)"O", pyws.get() ) );
if( !res ) {
PyErr_Print();
if ( !myInterp || !myModule )
return;
- if ( PyObject_HasAttrString( myModule, "preferenceChanged" ) ) {
+ if ( PyObject_HasAttrString( myModule, (char*)"preferenceChanged" ) ) {
PyObjWrapper res( PyObject_CallMethod( myModule,
(char*)"preferenceChanged",
(char*)"ss",
connectView( pview );
- if ( PyObject_HasAttrString( myModule, "activeViewChanged" ) )
+ if ( PyObject_HasAttrString( myModule, (char*)"activeViewChanged" ) )
{
if ( !pview )
return;
if ( !myInterp || !myModule || !pview )
return;
- if ( PyObject_HasAttrString( myModule, "viewCloned" ) )
+ if ( PyObject_HasAttrString( myModule, (char*)"viewCloned" ) )
{
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"viewCloned", (char*)"i", pview->getId() ) );
if( !res )
}
}
+/*!
+ \brief Signal handler tryClose(SUIT_ViewWindow*) of a view
+ \param pview view being closed
+*/
+void SALOME_PYQT_ModuleLight::onViewTryClose( SUIT_ViewWindow* pview )
+{
+ class ViewTryClose : public PyInterp_LockRequest
+ {
+ public:
+ ViewTryClose( PyInterp_Interp* _py_interp, SALOME_PYQT_ModuleLight* _obj, const SUIT_ViewWindow* _pview )
+ : PyInterp_LockRequest( _py_interp, 0, true ),
+ myObj(_obj),myView(_pview) {}
+
+ protected:
+ virtual void execute()
+ {
+ myObj->viewTryClose( myView );
+ }
+
+ private:
+ SALOME_PYQT_ModuleLight* myObj;
+ const SUIT_ViewWindow * myView;
+ };
+
+ PyInterp_Dispatcher::Get()->Exec( new ViewTryClose( myInterp, this, pview ) );
+}
+
+/*!
+ \brief Processes the view closing attempt, calls Python module's viewTryClose() method
+ \param pview view user tries to close
+*/
+void SALOME_PYQT_ModuleLight::viewTryClose( const SUIT_ViewWindow* pview )
+{
+ if ( !myInterp || !myModule )
+ return;
+
+ if ( PyObject_HasAttrString( myModule, (char*)"viewTryClose" ) )
+ {
+ PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"viewTryClose", (char*)"i", pview->getId() ) );
+ if ( !res )
+ {
+ PyErr_Print();
+ }
+ }
+}
+
/*!
\brief Signal handler closing(SUIT_ViewWindow*) of a view
\param pview view being closed
if ( !myInterp || !myModule )
return;
- if ( PyObject_HasAttrString( myModule, "viewClosed" ) )
+ if ( PyObject_HasAttrString( myModule, (char*)"viewClosed" ) )
{
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"viewClosed", (char*)"i", pview->getId() ) );
if ( !res )
if ( viewMgr )
{
+ disconnect( viewMgr, SIGNAL( tryCloseView( SUIT_ViewWindow* ) ),
+ this, SLOT( onViewTryClose( SUIT_ViewWindow* ) ) );
disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
- this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
+ this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
+ connect( viewMgr, SIGNAL( tryCloseView( SUIT_ViewWindow* ) ),
+ this, SLOT( onViewTryClose( SUIT_ViewWindow* ) ) );
connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
}
if ( !myInterp || !myModule || (it == theListOfFiles.end()))
return;
- if ( PyObject_HasAttrString(myModule, "saveFiles") ) {
+ if ( PyObject_HasAttrString(myModule, (char*)"saveFiles") ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"saveFiles",
(char*)"s", (*it).toLatin1().constData()));
if( !res ) {
#else
PyObjWrapper sipList( sipBuildResult( 0, "D", theList, sipType_QStringList , NULL) );
#endif
- if ( PyObject_HasAttrString(myModule , "openFiles") ) {
+ if ( PyObject_HasAttrString(myModule , (char*)"openFiles") ) {
PyObjWrapper res( PyObject_CallMethod( myModule, (char*)"openFiles",
(char*)"O", sipList.get()));
if( !res || !PyBool_Check( res )) {
void onGUIEvent();
void onActiveViewChanged( SUIT_ViewWindow* );
+ void onViewTryClose( SUIT_ViewWindow* );
void onViewClosed( SUIT_ViewWindow* );
void onViewCloned( SUIT_ViewWindow* );
protected:
/* create data model */
- virtual CAM_DataModel* createDataModel();
+ virtual CAM_DataModel* createDataModel();
private:
void init( CAM_Application* );
void setWorkSpace();
void activeViewChanged( const SUIT_ViewWindow* );
+ void viewTryClose( const SUIT_ViewWindow* );
void viewClosed( const SUIT_ViewWindow* );
void viewCloned( const SUIT_ViewWindow* );
void connectView( const SUIT_ViewWindow* );
return ProcessEvent( new TCreateView( type ) );
}
+/*!
+ \fn int SalomePyQt::createView( const QString& type, QWidget* w )
+ \brief Create new view with custom widget embedded and activate it
+ \param type viewer type
+ \param w custom widget
+ \return integer identifier of created view (or -1 if view could not be created)
+*/
+
+class TCreateViewWg: public SALOME_Event
+{
+public:
+ typedef int TResult;
+ TResult myResult;
+ QString myType;
+ QWidget* myWidget;
+ TCreateViewWg( const QString& theType, QWidget* w )
+ : myResult( -1 ),
+ myType( theType ),
+ myWidget( w ) {}
+ virtual void Execute()
+ {
+ LightApp_Application* app = getApplication();
+ if ( app )
+ {
+ SUIT_ViewManager* viewMgr = app->createViewManager( myType, myWidget );
+ if ( viewMgr )
+ {
+ SUIT_ViewWindow* wnd = viewMgr->getActiveView();
+ if ( wnd )
+ myResult = wnd->getId();
+ }
+ }
+ }
+};
+int SalomePyQt::createView( const QString& type, QWidget* w )
+{
+ return ProcessEvent( new TCreateViewWg( type, w ) );
+}
+
/*!
\fn bool SalomePyQt::closeView( const int id )
\brief Close view
return ProcessEvent( new TIsViewVisible( id ) );
}
+/*!
+ \fn bool SalomePyQt::setViewClosable( const int id, const bool on )
+ \brief Set / clear view's "closable" option. By default any view is closable
+ (i.e. can be closed by the user).
+ \param id window identifier
+ \param on new "closable" option's value
+*/
+
+void SalomePyQt::setViewClosable( const int id, const bool on )
+{
+ class TEvent: public SALOME_Event
+ {
+ int myWndId;
+ bool myOn;
+ public:
+ TEvent( const int id, const bool on )
+ : myWndId( id ), myOn( on ) {}
+ virtual void Execute()
+ {
+ SUIT_ViewWindow* wnd = getWnd( myWndId );
+ if ( wnd ) wnd->setClosable( myOn );
+ }
+ };
+ ProcessVoidEvent( new TEvent( id, on ) );
+}
+
+/*!
+ \fn bool SalomePyQt::isViewClosable( const int id )
+ \brief Check whether view is closable (i.e. can be closed by the user)
+ \param id window identifier
+ \return \c true if view is closable or \c false otherwise
+*/
+
+class TIsViewClosable: public SALOME_Event
+{
+public:
+ typedef bool TResult;
+ TResult myResult;
+ int myWndId;
+ TIsViewClosable( const int id )
+ : myResult( true ),
+ myWndId( id ) {}
+ virtual void Execute()
+ {
+ SUIT_ViewWindow* wnd = getWnd( myWndId );
+ if ( wnd )
+ myResult = wnd->closable();
+ }
+};
+
+bool SalomePyQt::isViewClosable( const int id )
+{
+ return ProcessEvent( new TIsViewClosable( id ) );
+}
+
/*!
\fn bool SalomePyQt::groupAllViews()
\brief Group all views to the single tab area
static QList<int> findViews( const QString& );
static bool activateView( const int );
static int createView( const QString& );
+ static int createView( const QString&, QWidget* );
static bool closeView( const int );
static int cloneView( const int );
- static bool isViewVisible( const int id );
-
+ static bool isViewVisible( const int );
+ static void setViewClosable( const int, const bool );
+ static bool isViewClosable( const int );
+
static bool groupAllViews();
static bool splitView( const int, const Orientation, const Action );
static bool moveView( const int, const int, const bool );
static QList<int> findViews( const QString& ) /ReleaseGIL/ ;
static bool activateView( const int ) /ReleaseGIL/ ;
static int createView( const QString& ) /ReleaseGIL/ ;
+ static int createView( const QString&, QWidget* ) /ReleaseGIL/ ;
static bool closeView( const int ) /ReleaseGIL/ ;
static int cloneView( const int ) /ReleaseGIL/ ;
static bool isViewVisible( const int id ) /ReleaseGIL/ ;
+ static void setViewClosable( const int id, const bool ) /ReleaseGIL/ ;
+ static bool isViewClosable( const int id ) /ReleaseGIL/ ;
static bool groupAllViews() /ReleaseGIL/ ;
static bool splitView( const int, Orientation, Action ) /ReleaseGIL/ ;
SUIT_Desktop* theDesktop,
SUIT_ViewModel* theViewModel )
: QObject( 0 ),
-myDesktop( theDesktop ),
-myTitle( "Default: %M - viewer %V" ),
-myStudy( NULL )
+ myDesktop( theDesktop ),
+ myTitle( "Default: %M - viewer %V" ),
+ myStudy( NULL )
{
myViewModel = 0;
myActiveView = 0;
connect(theView, SIGNAL(closing(SUIT_ViewWindow*)),
this, SLOT(onClosingView(SUIT_ViewWindow*)));
+ connect(theView, SIGNAL(tryClosing(SUIT_ViewWindow*)),
+ this, SIGNAL(tryCloseView(SUIT_ViewWindow*)));
+
connect(theView, SIGNAL(mousePressed(SUIT_ViewWindow*, QMouseEvent*)),
this, SLOT(onMousePressed(SUIT_ViewWindow*, QMouseEvent*)));
QPointer<SUIT_ViewWindow> view( theView );
+ view->setClosable( false );
view->hide();
if ( !view->testAttribute( Qt::WA_DeleteOnClose ) )
signals:
void lastViewClosed(SUIT_ViewManager*);
+ void tryCloseView(SUIT_ViewWindow*);
void deleteView(SUIT_ViewWindow*);
void viewCreated(SUIT_ViewWindow*);
void mousePress(SUIT_ViewWindow*, QMouseEvent*);
void SUIT_ViewWindow::closeEvent( QCloseEvent* e )
{
e->ignore();
- emit closing( this );
+ emit tryClosing( this );
+ if ( closable() ) emit closing( this );
}
/*! Context menu requested for event \a e.
return true;
}
+/*! Returns \c true if view window can be closed by the user
+*/
+bool SUIT_ViewWindow::closable() const
+{
+ QVariant val = property( "closable" );
+ return !val.isValid() || val.toBool();
+}
+
+/*! Set / reset "closable" option of the view window
+*/
+bool SUIT_ViewWindow::setClosable( const bool on )
+{
+ setProperty( "closable", on );
+}
+
/*!
\return string containing visual parameters of window
*/
-QString SUIT_ViewWindow::getVisualParameters()
+QString SUIT_ViewWindow::getVisualParameters()
{
return "empty";
}
bool onAccelAction( int );
+ bool closable() const;
+ bool setClosable( const bool );
+
virtual QString getVisualParameters();
virtual void setVisualParameters( const QString& parameters );
virtual void onDumpView();
signals:
+ void tryClosing( SUIT_ViewWindow* );
void closing( SUIT_ViewWindow* );
void mousePressed( SUIT_ViewWindow*, QMouseEvent* );
void mouseReleased( SUIT_ViewWindow*, QMouseEvent* );
QMap<QString, QVariant> myCustomData;
};
-#endif // !defined(AFX_SUIT_VIEWWINDOW_H__82C3D51A_6F10_45B0_BCFE_3CB3EF596A4D__INCLUDED_)
+#endif // SUIT_VIEWWINDOW_H
resources/vtk_view_perspective.png \
resources/vtk_view_parameters.png \
resources/vtk_view_style_switch.png \
+ resources/vtk_view_zooming_style_switch.png \
resources/vtk_view_recording_start.png \
resources/vtk_view_recording_play.png \
resources/vtk_view_recording_pause.png \
myControllerIncrement(SVTK_ControllerIncrement::New()),
myControllerOnKeyDown(SVTK_ControllerOnKeyDown::New()),
myHighlightSelectionPointActor(SVTK_Actor::New()),
- myRectBand(0)
+ myRectBand(0),
+ myIsAdvancedZoomingEnabled(false)
{
myPointPicker->Delete();
double zoomFactor = pow((double)1.1, dxf + dyf);
vtkCamera *aCam = GetCurrentRenderer()->GetActiveCamera();
- if (aCam->GetParallelProjection())
+ if (aCam->GetParallelProjection()) {
+ int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+ if( IsAdvancedZoomingEnabled() ) { // zoom relatively to the cursor
+ int* aSize = GetCurrentRenderer()->GetRenderWindow()->GetSize();
+ int w = aSize[0];
+ int h = aSize[1];
+ x0 = w / 2;
+ y0 = h / 2;
+ x1 = myOtherPoint.x();
+ y1 = h - myOtherPoint.y();
+ TranslateView( x0, y0, x1, y1 );
+ }
aCam->SetParallelScale(aCam->GetParallelScale()/zoomFactor);
+ if( IsAdvancedZoomingEnabled() )
+ TranslateView( x1, y1, x0, y0 );
+ }
else{
aCam->Dolly(zoomFactor); // Move camera in/out along projection direction
GetCurrentRenderer()->ResetCameraClippingRange();
int CurrentState() const { return State; }
+ void SetAdvancedZoomingEnabled( const bool theState ) { myIsAdvancedZoomingEnabled = theState; }
+ bool IsAdvancedZoomingEnabled() const { return myIsAdvancedZoomingEnabled; }
+
protected:
SVTK_InteractorStyle();
~SVTK_InteractorStyle();
bool myBBFirstCheck;
QRubberBand* myRectBand; //!< selection rectangle rubber band
+
+ bool myIsAdvancedZoomingEnabled;
};
#ifdef WIN32
myIncrementMode = 0;
myProjMode = 0;
myStyle = 0;
+ myZoomingStyle = 0;
mySpaceBtn[0] = 1;
mySpaceBtn[1] = 2;
mySpaceBtn[2] = 9;
aViewWindow->SetStaticTrihedronVisible( isStaticTrihedronVisible() );
aViewWindow->SetProjectionMode( projectionMode() );
aViewWindow->SetInteractionStyle( interactionStyle() );
+ aViewWindow->SetZoomingStyle( zoomingStyle() );
aViewWindow->SetIncrementalSpeed( incrementalSpeed(), incrementalSpeedMode() );
aViewWindow->SetSpacemouseButtons( spacemouseBtn(1), spacemouseBtn(2), spacemouseBtn(3) );
}
}
+/*!
+ \return zooming style
+*/
+int SVTK_Viewer::zoomingStyle() const
+{
+ return myZoomingStyle;
+}
+
+/*!
+ Sets zooming style: 0 - standard, 1 - advanced (at cursor)
+ \param theStyle - new zooming style
+*/
+void SVTK_Viewer::setZoomingStyle( const int theStyle )
+{
+ myZoomingStyle = theStyle;
+
+ if (SUIT_ViewManager* aViewManager = getViewManager()) {
+ QVector<SUIT_ViewWindow*> aViews = aViewManager->getViews();
+ for ( uint i = 0; i < aViews.count(); i++ )
+ {
+ if ( TViewWindow* aView = dynamic_cast<TViewWindow*>(aViews.at( i )) )
+ aView->SetZoomingStyle( theStyle );
+ }
+ }
+}
+
/*!
\return incremental speed value
*/
//! Sets interaction style
void setInteractionStyle( const int );
+ //! Gets zooming style
+ int zoomingStyle() const;
+
+ //! Sets zooming style
+ void setZoomingStyle( const int );
+
//! Get incremental speed (see #SVTK_InteractorStyle::ControllerIncrement)
int incrementalSpeed() const;
int myIncrementMode;
int myProjMode;
int myStyle;
+ int myZoomingStyle;
int mySpaceBtn[3];
};
myViewParameterDlg = new SVTK_ViewParameterDlg
( getAction( ViewParametersId ), this, "SVTK_ViewParameterDlg" );
- SVTK_InteractorStyle* aStyle = SVTK_InteractorStyle::New();
- myInteractor->PushInteractorStyle(aStyle);
- aStyle->Delete();
+ myDefaultInteractorStyle = SVTK_InteractorStyle::New();
+ myInteractor->PushInteractorStyle(myDefaultInteractorStyle);
+ myDefaultInteractorStyle->Delete();
myRecorder = SVTK_Recorder::New();
onSwitchInteractionStyle( theStyle==1 );
}
+/*!
+ Sets actual zooming style
+ \param theStyle - type of zooming style ( 0 - standard, 1 - advanced (at cursor) )
+*/
+void SVTK_ViewWindow::SetZoomingStyle(const int theStyle)
+{
+ onSwitchZoomingStyle( theStyle==1 );
+}
+
/*!
Switches "keyboard free" interaction style on/off
*/
if ( a->isChecked() != theOn ) a->setChecked( theOn );
}
+/*!
+ Toogles advanced zooming style (relatively to the cursor position) on/off
+*/
+void SVTK_ViewWindow::onSwitchZoomingStyle( bool theOn )
+{
+ if( myDefaultInteractorStyle.GetPointer() )
+ myDefaultInteractorStyle->SetAdvancedZoomingEnabled( theOn );
+ if( myKeyFreeInteractorStyle.GetPointer() )
+ myKeyFreeInteractorStyle->SetAdvancedZoomingEnabled( theOn );
+
+ // update action state if method is called outside
+ QtxAction* a = getAction( SwitchZoomingStyleId );
+ if ( a->isChecked() != theOn )
+ a->setChecked( theOn );
+}
+
/*!
Sets incremental speed
\param theValue - new incremental speed
*/
void SVTK_ViewWindow::onPerspectiveMode()
{
+ bool anIsParallelMode = toolMgr()->action( ParallelModeId )->isChecked();
+
+ // advanced zooming is not available in perspective mode
+ if( QtxAction* anAction = getAction( SwitchZoomingStyleId ) )
+ anAction->setEnabled( anIsParallelMode );
+
vtkCamera* aCamera = getRenderer()->GetActiveCamera();
- aCamera->SetParallelProjection(toolMgr()->action( ParallelModeId )->isChecked());
+ aCamera->SetParallelProjection(anIsParallelMode);
GetInteractor()->GetDevice()->CreateTimer(VTKI_TIMER_FIRST);
}
connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchInteractionStyle(bool)));
mgr->registerAction( anAction, SwitchInteractionStyleId );
+ // Switch between zomming styles
+ anAction = new QtxAction(tr("MNU_SVTK_ZOOMING_STYLE_SWITCH"),
+ theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_ZOOMING_STYLE_SWITCH" ) ),
+ tr( "MNU_SVTK_ZOOMING_STYLE_SWITCH" ), 0, this);
+ anAction->setStatusTip(tr("DSC_SVTK_ZOOMING_STYLE_SWITCH"));
+ anAction->setCheckable(true);
+ connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchZoomingStyle(bool)));
+ mgr->registerAction( anAction, SwitchZoomingStyleId );
+
// Start recording
myStartAction = new QtxAction(tr("MNU_SVTK_RECORDING_START"),
theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_RECORDING_START" ) ),
mgr->append( DumpId, myToolBar );
mgr->append( SwitchInteractionStyleId, myToolBar );
+ mgr->append( SwitchZoomingStyleId, myToolBar );
mgr->append( ViewTrihedronId, myToolBar );
QtxMultiAction* aScaleAction = new QtxMultiAction( this );
class SVTK_UpdateRateDlg;
class SVTK_CubeAxesDlg;
class SVTK_SetRotationPointDlg;
+class SVTK_InteractorStyle;
class SVTK_KeyFreeInteractorStyle;
class SVTK_ViewParameterDlg;
class SVTK_Recorder;
//! Redirect the request to #SVTK_MainWindow::SetInteractionStyle
virtual void SetInteractionStyle( const int );
+ //! Redirect the request to #SVTK_MainWindow::SetZoomingStyle
+ virtual void SetZoomingStyle( const int );
+
//! Redirect the request to #SVTK_MainWindow::SetSpacemouseButtons
virtual void SetSpacemouseButtons( const int, const int, const int );
void onViewParameters(bool theIsActivate);
void onSwitchInteractionStyle(bool theOn);
+ void onSwitchZoomingStyle(bool theOn);
void onStartRecording();
void onPlayRecording();
FrontId, BackId, TopId, BottomId, LeftId, RightId, ResetId,
ViewTrihedronId, NonIsometric, GraduatedAxes, UpdateRate,
ParallelModeId, ProjectionModeId, ViewParametersId, SwitchInteractionStyleId,
+ SwitchZoomingStyleId,
StartRecordingId, PlayRecordingId, PauseRecordingId, StopRecordingId };
SVTK_ViewModelBase* myModel;
SVTK_RenderWindowInteractor* myInteractor;
+ vtkSmartPointer<SVTK_InteractorStyle> myDefaultInteractorStyle;
vtkSmartPointer<SVTK_KeyFreeInteractorStyle> myKeyFreeInteractorStyle;
QString myVisualParams; // used for delayed setting of view parameters
<source>ICON_SVTK_STYLE_SWITCH</source>
<translation>vtk_view_style_switch.png</translation>
</message>
+ <message>
+ <source>ICON_SVTK_ZOOMING_STYLE_SWITCH</source>
+ <translation>vtk_view_zooming_style_switch.png</translation>
+ </message>
<message>
<source>ICON_SVTK_RECORDING_START</source>
<translation>vtk_view_recording_start.png</translation>
<source>MNU_SVTK_STYLE_SWITCH</source>
<translation>Interaction Style Switch</translation>
</message>
+ <message>
+ <source>DSC_SVTK_ZOOMING_STYLE_SWITCH</source>
+ <translation>Zooming style switch</translation>
+ </message>
+ <message>
+ <source>MNU_SVTK_ZOOMING_STYLE_SWITCH</source>
+ <translation>Zomming style switch</translation>
+ </message>
</context>
<context>
<name>SVTK_FontWidget</name>
<parameter name="iso_number_v" value="1" />
<parameter name="trihedron_size" value="100" />
<parameter name="navigation_mode" value="0"/>
+ <parameter name="zooming_mode" value="0" />
</section>
<section name="VTKViewer" >
<!-- VTK viewer preferences -->
<parameter name="group_names_transparency" value="0.5"/>
<parameter name="projection_mode" value="0"/>
<parameter name="navigation_mode" value="0"/>
+ <parameter name="zooming_mode" value="0" />
<parameter name="speed_mode" value="0"/>
<parameter name="speed_value" value="10"/>
<parameter name="show_static_trihedron" value="true" />
