}
/// Constructor
- /// \param theFeature a model feature
+ /// \param theResult an object
/// \param theShape a viewer shape
/// \param theOwner a selection owner
ModuleBase_ViewerPrs(ObjectPtr theResult, const TopoDS_Shape& theShape,
{
}
- /// Sets the feature.
- /// \param theFeature a feature instance
+ /// Sets the object.
+ /// \param theResult an object instance
void setFeature(ObjectPtr theResult)
{
myResult = theResult;
return myResult;
}
- /// Returns the presentation owner
- /// \param the owner
+ /// Set the presentation owner
+ /// \param theOwner an owner to set
void setOwner(Handle_SelectMgr_EntityOwner theOwner)
{
myOwner = theOwner;
return myShape;
}
+ /// Set interactive object
+ /// \param theIO an interactive object
void setInteractive(const Handle(AIS_InteractiveObject)& theIO)
{
myInteractive = theIO;
}
+ /// Returns interactive object if it is installed
Handle(AIS_InteractiveObject) interactive() const
{
return myInteractive;
}
+ /// Returns True if the current object is equal to the given one
+ /// \param thePrs an object to compare
bool operator==(const ModuleBase_ViewerPrs& thePrs)
{
bool aResult = (myResult.get() == thePrs.object().get());
ObjectPtr myResult; /// the feature
Handle(SelectMgr_EntityOwner) myOwner; /// the selection owner
TopoDS_Shape myShape; /// the shape
- Handle(AIS_InteractiveObject) myInteractive;
+ Handle(AIS_InteractiveObject) myInteractive; /// interactive object
};
#endif
virtual Handle(V3d_View) v3dView() const;
+ /// Set the current viewer
+ /// \param theViewer a viewer instance
void setViewer(OCCViewer_Viewer* theViewer) { myViewer = theViewer; }
+
+ /// Returns current viewer
OCCViewer_Viewer* viewer() const { return myViewer; }
private:
/// \param theZ the Z projection value
virtual void setViewProjection(double theX, double theY, double theZ);
+ /// Set selector
+ /// \param theSel a selector instance
void setSelector(NewGeom_OCCSelector* theSel);
/// Add selection filter to the viewer
/// Remove all selection filters from the viewer
virtual void clearSelectionFilters();
+ /// Returns current selector
NewGeom_OCCSelector* selector() const
{
return mySelector;
SET(PROJECT_HEADERS
PartSet.h
PartSet_Constants.h
- PartSet_EditLine.h
PartSet_Module.h
PartSet_Tools.h
PartSet_WidgetSketchLabel.h
)
SET(PROJECT_SOURCES
- PartSet_EditLine.cpp
PartSet_Module.cpp
PartSet_Tools.cpp
PartSet_WidgetSketchLabel.cpp
+++ /dev/null
-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: PartSet_EditLine.h
-// Created: 02 June 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_EditLine.h>
-
-#include <QLineEdit>
-
-PartSet_EditLine::PartSet_EditLine(QWidget* theParent)
- : QObject(theParent)
-{
- myEditor = new QLineEdit(theParent);
- myEditor->setWindowFlags(Qt::ToolTip);
- myEditor->setFocusPolicy(Qt::StrongFocus);
-
- connect(myEditor, SIGNAL(returnPressed()), this, SLOT(onStopEditing()));
-}
-
-void PartSet_EditLine::start(const QPoint& thePoint, double theValue)
-{
- myEditor->move(thePoint);
- myEditor->setText(QString::number(theValue));
- myEditor->show();
-
- myEditor->selectAll();
- myEditor->setFocus();
-}
-
-bool PartSet_EditLine::isStarted() const
-{
- return myEditor->isVisible();
-}
-
-void PartSet_EditLine::stop()
-{
- myEditor->hide();
-}
-
-double PartSet_EditLine::getValue() const
-{
- return myEditor->text().toDouble();
-}
-
-void PartSet_EditLine::onStopEditing()
-{
- stop();
- emit stopped(getValue());
-}
+++ /dev/null
-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: PartSet_EditLine.h
-// Created: 02 Jun 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_EditLine_H
-#define PartSet_EditLine_H
-
-#include "PartSet.h"
-
-#include <QObject>
-#include <QPoint>
-
-class QLineEdit;
-class QWidget;
-
-/*!
- \class PartSet_EditLine
- * \brief The class to give an editor to modify a real value
- */
-class PARTSET_EXPORT PartSet_EditLine : public QObject
-{
-Q_OBJECT
- public:
- /// Constructor
- PartSet_EditLine(QWidget* theParent);
- /// Destructor
- virtual ~PartSet_EditLine()
- {
- }
- ;
-
- /// Show the editor in the given global position
- /// \param thePoint a position
- /// \param theValue a value for the editor
- void start(const QPoint& thePoint, double theValue);
-
- /// Checks whether the editor is started
- /// \returns true if the editor is activated
- bool isStarted() const;
-
- /// Stop the editor, in other words hide it
- void stop();
-
-signals:
- /// Signals about the editing stop
- /// \param theValue the editor value
- void stopped(double theValue);
-
- protected:
- /// Returns the editor value
- /// \return the real value
- double getValue() const;
-
- protected slots:
- /// Slot to check the editing stop
- void onStopEditing();
-
- protected:
- QLineEdit* myEditor; /// the value editor
-};
-
-#endif
/**
+* \class PartSet_GlobalFilter
+* \ingroup Module
* A class which filters groups object in addition to documents (see issue #310)
*/
DEFINE_STANDARD_HANDLE(PartSet_GlobalFilter, ModuleBase_ShapeDocumentFilter);
class PartSet_GlobalFilter: public ModuleBase_ShapeDocumentFilter
{
public:
+ /// Constructor
+ /// \param theWorkshop a pointer to workshop
PartSet_GlobalFilter(ModuleBase_IWorkshop* theWorkshop)
: ModuleBase_ShapeDocumentFilter(theWorkshop) {}
+ /// Returns True if selected presentation can be selected
+ /// \param theOwner an owner of the persentation
Standard_EXPORT virtual Standard_Boolean IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const;
DEFINE_STANDARD_RTTI(PartSet_GlobalFilter)
class ModuleBase_Operation;
class ModuleBase_IViewWindow;
+/**
+* \ingroup Module
+* Implementation of Partset module
+*/
class PARTSET_EXPORT PartSet_Module : public ModuleBase_IModule
{
Q_OBJECT
};
public:
+ /// Constructor
+ /// \param theWshop a pointer to a workshop
PartSet_Module(ModuleBase_IWorkshop* theWshop);
virtual ~PartSet_Module();
/// Called when previous operation is finished
virtual void onSelectionChanged();
- /// SLOT, that is called by mouse press in the viewer.
- /// \param theWnd - the window where the event happens
- /// \param theEvent the mouse event
- //void onMousePressed(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
-
- /// SLOT, that is called by mouse release in the viewer.
- /// \param theWnd - the window where the event happens
- /// \param theEvent the mouse event
- //void onMouseReleased(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
-
- /// SLOT, that is called by mouse move in the viewer.
- /// \param theWnd - the window where the event happens
- /// \param theEvent the mouse event
- //void onMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
-
- /// SLOT, that is called by mouse double click in the viewer.
- /// \param theWnd - the window where the event happens
- /// \param theEvent the mouse event
- //void onMouseDoubleClick(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
-
/// SLOT, that is called by key release in the viewer.
- /// The mouse moved point is sent to the current operation to be processed.
+ /// \param theWnd a view window
/// \param theEvent the key event
void onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent);
virtual void registerFilters();
private slots:
+ /// Processing of vertex selected
void onVertexSelected();
-
private:
-
/// Breaks sequense of automatically resterted operations
void breakOperationSequence();
+++ /dev/null
-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: PartSet_Operation.cpp
-// Created: 24 Nov 2014
-// Author: Vitaly SMETANNIKOV
-
-#include "PartSet_Operation.h"
-
-#include <ModuleBase_IWorkshop.h>
-#include <ModuleBase_ISelection.h>
-
-void PartSet_Operation::onSelectionChanged()
-{
- if (isEditOperation()) {
- ModuleBase_ISelection* aSelection = myWorkshop->selection();
- QList<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
- QList<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- }
-}
\ No newline at end of file
+++ /dev/null
-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: PartSet_Operation.h
-// Created: 24 Nov 2014
-// Author: Vitaly SMETANNIKOV
-
-#ifndef PartSet_Operation_H
-#define PartSet_Operation_H
-
-#include "PartSet.h"
-
-#include <ModuleBase_Operation.h>
-
-class ModuleBase_IWorkshop;
-
-class PARTSET_EXPORT PartSet_Operation : public ModuleBase_Operation
-{
-Q_OBJECT
- public:
- PartSet_Operation(const QString& theId = "", QObject* theParent = 0)
- :ModuleBase_Operation(theId, theParent) {}
-
- void setWorkshop(ModuleBase_IWorkshop* theWorkshop) { myWorkshop = theWorkshop; }
-
-public slots:
- void onSelectionChanged();
-
-private:
- ModuleBase_IWorkshop* myWorkshop;
-};
-
-#endif
\ No newline at end of file
class QMouseEvent;
/**
+* \ingroup Module
* A class for management of sketch operations
*/
class PARTSET_EXPORT PartSet_SketcherMgr : public QObject
double myCurX, myCurY; /// the point coordinates
};
public:
+ /// Constructor
+ /// \param theModule a pointer to PartSet module
PartSet_SketcherMgr(PartSet_Module* theModule);
virtual ~PartSet_SketcherMgr();
+ /// Returns list of strings which contains id's of sketch operations
static QStringList sketchOperationIdList();
/// Launches the operation from current highlighting
void launchEditing();
- // Returns current Sketch feature/ Returns NULL if there is no launched sketch operation
+ /// Returns current Sketch feature/ Returns NULL if there is no launched sketch operation
CompositeFeaturePtr activeSketch() const { return myCurrentSketch; }
/// Starts sketch operation
- void startSketch(ModuleBase_Operation* theOperation);
+ void startSketch(ModuleBase_Operation* );
/// Stops sketch operation
- void stopSketch(ModuleBase_Operation* theOperation);
+ void stopSketch(ModuleBase_Operation* );
public slots:
+ /// Process sketch plane selected event
void onPlaneSelected(const std::shared_ptr<GeomAPI_Pln>& thePln);
class GeomAPI_Vertex;
/*!
- \class PartSet_Tools
+ * \class PartSet_Tools
+ * \ingroup Module
* \brief The operation for the sketch feature creation
*/
class PARTSET_EXPORT PartSet_Tools
/// Converts the 2D screen point to the 3D point on the view according to the point of view
/// \param thePoint a screen point
/// \param theView a 3D view
- // Transferred to ModuleBase
static gp_Pnt convertClickToPoint(QPoint thePoint, Handle_V3d_View theView);
/// \brief Converts the 3D point to the projected coodinates on the sketch plane.
/// \param thePoint the 3D point in the viewer
/// \param theSketch the sketch feature
+ /// \param theView a view 3d object
/// \param theX the X coordinate
/// \param theY the Y coordinate
static void convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch,
/// \param theX the X coordinate
/// \param theY the Y coordinate
/// \param theSketch the sketch feature
- /// \param thePoint the 3D point in the viewer
static std::shared_ptr<GeomAPI_Pnt> convertTo3D(const double theX, const double theY, FeaturePtr theSketch);
/// Returns an object that is under the mouse point. Firstly it checks the highlighting,
/// Returns pointer to the root document.
static std::shared_ptr<ModelAPI_Document> document();
-
+ /// Find an attribute which corresponds to a given pont coordinates
+ /// \param theSketch the sketch feature
+ /// \param theX X coordinate
+ /// \param theY Y coordinate
+ /// \param theTolerance tolerance
+ /// \param theIgnore list of features which has to be ignored
static std::shared_ptr<GeomDataAPI_Point2D> findAttributePoint(CompositeFeaturePtr theSketch,
double theX, double theY, double theTolerance, const QList<FeaturePtr>& theIgnore = QList<FeaturePtr>());
/// \brief Save the double to the feature. If the attribute is double, it is filled.
/// \param theFeature the feature
- /// \param theValue the horizontal coordinate
+ /// \param theX the horizontal coordinate
/// \param theAttribute the feature attribute
static void setFeatureValue(FeaturePtr theFeature, double theX, const std::string& theAttribute);
const std::string& theKind);
/// Creates a constraint on two points
+ /// \param theSketch a sketch feature
/// \param thePoint1 the first point
- /// \param thePoint1 the second point
+ /// \param thePoint2 the second point
static void createConstraint(CompositeFeaturePtr theSketch,
std::shared_ptr<GeomDataAPI_Point2D> thePoint1,
std::shared_ptr<GeomDataAPI_Point2D> thePoint2);
/// Creates a line (arc or circle) by given edge
/// Created line will have fixed constraint
- /// \param theEdge - an edge
- /// \return - result of created feature
+ /// \param theShape an edge
+ /// \param theObject a selected result object
+ /// \param theSketch a sketch feature
+ /// \return result of created feature
static ResultPtr createFixedObjectByEdge(const TopoDS_Shape& theShape,
const ObjectPtr& theObject,
CompositeFeaturePtr theSketch);
PARTSET_EXPORT virtual bool isValid(const ModuleBase_ISelection* theSelection) const;
};
+/**
+* \ingroup Module
+* A validator which checks that objects selected for feature attributes are different (not the same)
+*/
class PartSet_DifferentObjectsValidator : public ModelAPI_RefAttrValidator
{
public:
+ /// Returns True if the feature is valid
+ /// \param theFeature a feature to check
+ /// \param theArguments a list of arguments (names of attributes to check)
+ /// \param theObject a selected object
virtual bool isValid(const FeaturePtr& theFeature, const std::list<std::string>& theArguments,
const ObjectPtr& theObject) const;
+
//! Returns true if the attribute is good for the feature attribute
+ //! \param theFeature a feature to check
+ //! \param theArguments a list of arguments (names of attributes to check)
+ //! \param theAttribute an attribute
virtual bool isValid(const FeaturePtr& theFeature, const std::list<std::string>& theArguments,
const AttributePtr& theAttribute) const;
+ //! Returns true if the attribute is good for the feature attribute
+ //! \param theAttribute an attribute
+ //! \param theArguments a list of arguments (names of attributes to check)
virtual bool isValid(const AttributePtr& theAttribute,
const std::list<std::string>& theArguments) const;
};
/**
-* aValidator which validates tha selected object is a Sketch
+* \ingroup Module
+* A Validator which validates tha selected object is a Sketch
*/
class PartSet_SketchValidator : public ModelAPI_ResultValidator
{
public:
+ /// Returns True if the given object is a sketch
+ /// \param theObject an object
virtual bool isValid(const ObjectPtr theObject) const;
};
class QMouseEvent;
/**\class PartSet_WidgetPoint2D
- * \ingroup GUI
- * \brief Custom widget. An abstract class to be redefined to fill with some GUI controls
+ * \ingroup Module
+ * \brief Implementation of model widget to provide widget to input point 2d
+ * In XML can be defined as folloung:
+ * \code
+ * <sketch-2dpoint_selector id="CircleCenter" title="Center" tooltip="Center coordinates"/>
+ * \endcode
*/
class PARTSET_EXPORT PartSet_WidgetPoint2D : public ModuleBase_ModelWidget
{
Q_OBJECT
public:
/// Constructor
- /// \theParent the parent object
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParent the parent object
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParentId is Id of a parent of the current attribute
PartSet_WidgetPoint2D(QWidget* theParent, const Config_WidgetAPI* theData,
const std::string& theParentId);
/// Destructor
/// \param theValue the wrapped widget value
virtual bool setSelection(ModuleBase_ViewerPrs theValue);
- /// Saves the internal parameters to the given feature
- /// \param theObject a model feature to be changed
virtual bool storeValue() const;
virtual bool restoreValue();
/// The methiod called when widget is deactivated
virtual void deactivate();
+ /// Return workshop
XGUI_Workshop* workshop() const { return myWorkshop; }
+ /// Set workshop
void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
/// \returns the sketch instance
CompositeFeaturePtr sketch() const { return mySketch; }
+
+ /// Set sketch instance
void setSketch(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
/// Fill the widget values by given point
- /// \param thePoint the point
+ /// \param theX the X coordinate
+ /// \param theY the Y coordinate
void setPoint(double theX, double theY);
/// Returns coordinate X currently defined in the control
signals:
/// Signal about selection of an existing vertex from an object
- /// \param theObject - the selected object
- /// \param theShape - the selected shape
void vertexSelected();
protected slots:
+ /// Process mouse release event
+ /// \param theWnd a view window
+ /// \param theEvent a mouse event
void onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+
+ /// Process mouse move event
+ /// \param theWnd a view window
+ /// \param theEvent a mouse event
void onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
private slots:
+ /// Process value changed event
void onValuesChanged();
private:
+ /// Returns point 2d from selected vertex
+ /// \param theView a view window
+ /// \param theShape a vertex shape
+ /// \param theX an output value of X coordinate
+ /// \param theY an output value of Y coordinate
bool getPoint2d(const Handle(V3d_View)& theView, const TopoDS_Shape& theShape,
double& theX, double& theY) const;
class ModuleBase_IViewWindow;
class QMouseEvent;
+/**
+* \ingroup Module
+* Implementation of model widget for widget which provides input of a distance between two points
+* In XML file can be defined as following:
+* \code
+* <point2ddistance id="CircleRadius"
+* first_point="CircleCenter"
+* label="Radius:"
+* min="0"
+* step="1.0"
+* default="0"
+* icon=":icons/radius.png"
+* tooltip="Set radius">
+* <validator id="GeomValidators_Positive"/>
+* </point2ddistance>
+* \endcode
+*/
class PARTSET_EXPORT PartSet_WidgetPoint2dDistance : public ModuleBase_WidgetDoubleValue
{
Q_OBJECT
public:
/// Constructor
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParent the parent object
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParentId is Id of a parent of the current attribute
PartSet_WidgetPoint2dDistance(QWidget* theParent, const Config_WidgetAPI* theData,
const std::string& theParentId);
/// The methiod called when widget is deactivated
virtual void deactivate();
- /// Set the given wrapped value to the current widget
- /// This value should be processed in the widget according to the needs
- /// \param theValue the wrapped widget value
- //virtual bool setValue(ModuleBase_WidgetValue* theValue);
-
+ /// Returns workshop
XGUI_Workshop* workshop() const { return myWorkshop; }
+ /// Set workshop
+ /// \param theWork a pointer to workshop
void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
/// \returns the sketch instance
CompositeFeaturePtr sketch() const { return mySketch; }
+
+ /// Set sketch instance
void setSketch(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
protected slots:
+ /// Process of mouse release
+ /// \param theWnd a pointer to a window
+ /// \param theEvent a mouse event
void onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+
+ /// Process of mouse move
+ /// \param theWnd a pointer to a window
+ /// \param theEvent a mouse event
void onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
protected:
void setPoint(FeaturePtr theFeature, const std::shared_ptr<GeomAPI_Pnt2d>& thePnt);
private slots:
+ /// Process values changed event
void onValuesChanged();
private:
#include <ModelAPI_CompositeFeature.h>
+
+/**
+* \ingroup Module
+* Customosation of ModuleBase_WidgetShapeSelector in order to provide
+* working with sketch specific objects.
+*/
class PARTSET_EXPORT PartSet_WidgetShapeSelector: public ModuleBase_WidgetShapeSelector
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent the parent object
+ /// \param theWorkshop instance of workshop interface
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParentId is Id of a parent of the current attribute
PartSet_WidgetShapeSelector(QWidget* theParent, ModuleBase_IWorkshop* theWorkshop,
const Config_WidgetAPI* theData, const std::string& theParentId)
: ModuleBase_WidgetShapeSelector(theParent, theWorkshop, theData, theParentId) {}
virtual ~PartSet_WidgetShapeSelector() {}
- /// Saves the internal parameters to the given feature
virtual bool storeValue() const;
+ /// Set sketcher
+ /// \param theSketch a sketcher object
void setSketcher(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
+
+ /// Retrurns installed sketcher
CompositeFeaturePtr sketch() const { return mySketch; }
protected:
virtual bool isValid(ObjectPtr theObj, std::shared_ptr<GeomAPI_Shape> theShape);
private:
+ /// Pointer to a sketch
CompositeFeaturePtr mySketch;
};
-
+/**
+* \ingroup Module
+* Customosation of ModuleBase_WidgetShapeSelector in order to provide
+* working with constraints.
+*/
class PARTSET_EXPORT PartSet_WidgetConstraintShapeSelector: public ModuleBase_WidgetShapeSelector
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent the parent object
+ /// \param theWorkshop instance of workshop interface
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParentId is Id of a parent of the current attribute
PartSet_WidgetConstraintShapeSelector(QWidget* theParent, ModuleBase_IWorkshop* theWorkshop,
const Config_WidgetAPI* theData, const std::string& theParentId)
: ModuleBase_WidgetShapeSelector(theParent, theWorkshop, theData, theParentId) {}
/// Saves the internal parameters to the given feature
virtual bool storeValue() const;
+ /// Set sketcher
+ /// \param theSketch a sketcher object
void setSketcher(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
+
+ /// Retrurns installed sketcher
CompositeFeaturePtr sketch() const { return mySketch; }
private:
+ /// Pointer to a sketch
CompositeFeaturePtr mySketch;
};
class XGUI_OperationMgr;
class XGUI_Workshop;
+/**
+* \ingroup Module
+* A model widget implementation for a label which provides specific behaviour
+* for sketcher starting and launching operations
+*/
class PARTSET_EXPORT PartSet_WidgetSketchLabel : public ModuleBase_ModelWidget
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent the parent object
+ /// \param theData the widget configuation. The attribute of the model widget is obtained from
+ /// \param theParentId is Id of a parent of the current attribute
PartSet_WidgetSketchLabel(QWidget* theParent, const Config_WidgetAPI* theData,
const std::string& theParentId);
virtual ~PartSet_WidgetSketchLabel();
- /// Saves the internal parameters to the given feature
- /// \param theFeature a model feature to be changed
virtual bool storeValue() const
{
return true;
/// The methiod called when widget is deactivated
virtual void deactivate();
+ /// Returns pointer to workshop
XGUI_Workshop* workshop() const { return myWorkshop; }
+ /// Set pointer to workshop
+ /// \param theWork a pointer to workshop
void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
+ /// Returns sketcher plane
std::shared_ptr<GeomAPI_Pln> plane() const;
signals:
+ /// Signal on plane selection
void planeSelected(const std::shared_ptr<GeomAPI_Pln>& thePln);
private slots:
+ /// Slot on plane selection
void onPlaneSelected();
+
+ /// Set sketch specific mode of selection
void setSketchingMode();
private:
+ /// Create preview of planes for sketch plane selection
+ /// \param theOrigin an origin of the plane
+ /// \param theNorm a normal vector of the plane
+ /// \param theRGB a color of plane presentation [r, g, b] array
AISObjectPtr createPreviewPlane(std::shared_ptr<GeomAPI_Pnt> theOrigin,
std::shared_ptr<GeomAPI_Dir> theNorm,
const int theRGB[3]);
+ /// Set sketch plane by shape
+ /// \param theShape a planar face
std::shared_ptr<GeomAPI_Dir> setSketchPlane(const TopoDS_Shape& theShape);
+ /// Erase preview planes
void erasePreviewPlanes();
+
+ /// Show preview planes
void showPreviewPlanes();
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_ContextMenuMgr(XGUI_Workshop* theParent);
virtual ~XGUI_ContextMenuMgr();
void createActions();
/// Returns action according to the given ID
+ /// \param theId an id of an action
QAction* action(const QString& theId) const;
/// Returns list of registered actions Ids
void connectViewer() const;
/// Add menu atems for viewer into the given menu (used in SALOME mode)
+ /// \param theMenu a menu instance
void addViewerItems(QMenu* theMenu) const;
signals:
+ /// Signal aabout triggered action
+ /// \param theId an id of triggered action
+ /// \param isChecked is checked flag
void actionTriggered(const QString& theId, bool isChecked);
private slots:
+ /// Process action event
+ /// \param isChecked a checked action flag
void onAction(bool isChecked);
+ /// Process context menu event
+ /// \param theEvent a context menu event
void onContextMenuRequest(QContextMenuEvent* theEvent);
private:
*/
void addAction(const QString& theId, QAction* theAction);
+ /// Creates menu for object browser
QMenu* objectBrowserMenu() const;
+
+ /// Creates menu for viewer
QMenu* viewerMenu() const;
+ /// Map of created actions [id : Action]
QMap<QString, QAction*> myActions;
+ /// Reference to workshop
XGUI_Workshop* myWorkshop;
};
class XGUI_EXPORT XGUI_FeaturesModel : public QAbstractItemModel
{
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_FeaturesModel(QObject* theParent)
: QAbstractItemModel(theParent),
myItemsColor(Qt::black)
//! Returns Feature object by the given Model index.
//! Returns 0 if the given index is not index of a feature
+ /// \param theIndex a model index
virtual ObjectPtr object(const QModelIndex& theIndex) const = 0;
//! Returns QModelIndex which corresponds to the given feature
virtual QModelIndex findParent(const ObjectPtr& theObject) const = 0;
//! Returns index corresponded to the group
+ //! \param theGroup a group name
virtual QModelIndex findGroup(const std::string& theGroup) const = 0;
+ //! Set color of items
void setItemsColor(const QColor& theColor)
{
myItemsColor = theColor;
}
+ //! Returns color of items
QColor itemsColor() const
{
return myItemsColor;
}
protected:
+ /// Color of items
QColor myItemsColor;
};
class XGUI_PartModel : public XGUI_FeaturesModel
{
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_PartModel(QObject* theParent)
: XGUI_FeaturesModel(theParent)
{
}
+ /// Set part id
+ /// \param theId a new id
void setPartId(int theId)
{
myId = theId;
}
//! Returns true if the given document is a sub-document of this tree
+ //! \param theDoc a document to check
virtual bool hasDocument(const DocumentPtr& theDoc) const = 0;
//! Return a Part object
{
Q_OBJECT
public:
-
+ /// Constructor
+ /// \param theParent a parent object
XGUI_DocumentDataModel(QObject* theParent);
virtual ~XGUI_DocumentDataModel();
- // Event Listener method
+ /// Event Listener method
+ /// \param theMessage an event message
virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
+ /// Returns the data stored under the given role for the item referred to by the index.
+ /// \param theIndex a model index
+ /// \param theRole a data role (see Qt::ItemDataRole)
virtual QVariant data(const QModelIndex& theIndex, int theRole) const;
+
+ /// Returns the data for the given role and section in the header with the specified orientation.
+ /// \param theSection a section
+ /// \param theOrient an orientation
+ /// \param theRole a data role (see Qt::ItemDataRole)
virtual QVariant headerData(int theSection, Qt::Orientation theOrient, int theRole =
Qt::DisplayRole) const;
+ /// Returns the number of rows under the given parent. When the parent is valid it means that
+ /// rowCount is returning the number of children of parent.
+ /// \param theParent a parent model index
virtual int rowCount(const QModelIndex& theParent = QModelIndex()) const;
+
+ /// Returns the number of columns for the children of the given parent.
+ /// It has a one column
+ /// \param theParent a parent model index
virtual int columnCount(const QModelIndex& theParent = QModelIndex()) const;
- virtual QModelIndex index(int theRow, int theColumn, const QModelIndex &parent =
+ /// Returns the index of the item in the model specified by the given row, column and parent index.
+ /// \param theRow a row
+ /// \param theColumn a column
+ /// \param theParent a parent model index
+ virtual QModelIndex index(int theRow, int theColumn, const QModelIndex &theParent =
QModelIndex()) const;
+ /// Returns the parent of the model item with the given index.
+ /// If the item has no parent, an invalid QModelIndex is returned.
+ /// \param theIndex a model index
virtual QModelIndex parent(const QModelIndex& theIndex) const;
+ /// Returns true if parent has any children; otherwise returns false.
+ /// \param theParent a parent model index
virtual bool hasChildren(const QModelIndex& theParent = QModelIndex()) const;
+ /// Inserts count rows into the model before the given row.
+ /// Items in the new row will be children of the item represented by the parent model index.
+ /// \param theRow a start row
+ /// \param theCount a nember of rows to insert
+ /// \param theParent a parent model index
bool insertRows(int theRow, int theCount, const QModelIndex& theParent = QModelIndex());
+ /// Removes count rows starting with the given row under parent parent from the model.
+ /// \param theRow a start row
+ /// \param theCount a nember of rows to remove
+ /// \param theParent a parent model index
bool removeRows(int theRow, int theCount, const QModelIndex& theParent = QModelIndex());
+ /// Returns the item flags for the given index.
+ /// \param theIndex a model index
Qt::ItemFlags flags(const QModelIndex& theIndex) const;
//! Returns an object by the given Model index.
//! Returns 0 if the given index is not index of an object
ObjectPtr object(const QModelIndex& theIndex) const;
+ //! Returns index of the object
+ //! \param theObject object to find
QModelIndex objectIndex(const ObjectPtr theObject) const;
//! Returns QModelIndex which corresponds to the given part
//! If the object is not found then index is not valid
+ //! \param thePart a part for analysis
QModelIndex partIndex(const ResultPartPtr& thePart) const;
//! Activates a part data model if the index is a Part node index.
//! Returns true if active part changed.
+ //! \param theIndex a model index
bool activatedIndex(const QModelIndex& theIndex);
//! Retrurns active part
//! Deactivates a Part
void deactivatePart();
+ //! Rebuild data tree
void rebuildDataTree();
//! Clear internal data
class XGUI_Displayer;
/**
+ * \ingroup GUI
* Implementation of IWorkshop interface which provides access to Workshop sevices at module level
*/
class XGUI_EXPORT XGUI_ModuleConnector : public ModuleBase_IWorkshop
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theWorkshop a workshop
XGUI_ModuleConnector(XGUI_Workshop* theWorkshop);
virtual ~XGUI_ModuleConnector();
//! If the list is empty then selection will be cleared
virtual void setSelected(const QObjectPtrList& theFeatures);
+ //! Returns workshop
XGUI_Workshop* workshop() const { return myWorkshop; }
private:
+ /// Reference to workshop
XGUI_Workshop* myWorkshop;
/// A filter which provides selection within a current document or whole PartSet
/// else, or if there is no parent - returns NULL
ModuleBase_Operation* previousOperation(ModuleBase_Operation* theOperation) const;
+ /// Redefinition of virtual function
virtual bool eventFilter(QObject *theObject, QEvent *theEvent);
/// Start the operation and append it to the stack of operations
/// \return the state whether the current operation is started
bool startOperation(ModuleBase_Operation* theOperation);
+ /// Abort all operations
bool abortAllOperations();
/// Returns whether the operation can be started. Check if there is already started operation and
/// Commits the current operatin if it is valid
bool commitOperation();
+
/// Sets the current operation or NULL
/// \param theOperation the started operation
- /// \param isCheckBeforeStart the flag whether to check whether the operation can be started
- /// \return the state whether the operation is resumed
void resumeOperation(ModuleBase_Operation* theOperation);
public slots:
/// SLOT, that is called by the key in the property panel is clicked.
- /// \param theName the attribute name
/// \param theEvent the mouse event
bool onKeyReleased(QKeyEvent* theEvent);
/// Slot that is called by an operation stop. Removes the stopped operation form the stack.
/// If there is a suspended operation, restart it.
void onOperationStopped();
+
+ /// Slot called on operation start
void onOperationStarted();
+
+ /// Slot called on operation abort
void onOperationAborted();
+
+ /// Slot called on operation commit
void onOperationCommitted();
+
+ /// Slot called on operation resume
void onOperationResumed();
private:
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_TopDataModel(QObject* theParent);
virtual ~XGUI_TopDataModel();
// Reimpl from QAbstractItemModel
+
+ /// Returns the data stored under the given role for the item referred to by the index.
+ /// \param theIndex a model index
+ /// \param theRole a data role (see Qt::ItemDataRole)
virtual QVariant data(const QModelIndex& theIndex, int theRole) const;
- virtual QVariant headerData(int section, Qt::Orientation orientation,
- int role = Qt::DisplayRole) const;
- virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
- virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
+ /// Returns the data for the given role and section in the header with the specified orientation.
+ /// \param theSection a section
+ /// \param theOrient an orientation
+ /// \param theRole a data role (see Qt::ItemDataRole)
+ virtual QVariant headerData(int theSection, Qt::Orientation theOrient,
+ int theRole = Qt::DisplayRole) const;
+
+ /// Returns the number of rows under the given parent. When the parent is valid it means that
+ /// rowCount is returning the number of children of parent.
+ /// \param theParent a parent model index
+ virtual int rowCount(const QModelIndex &theParent = QModelIndex()) const;
+
+ /// Returns the number of columns for the children of the given parent.
+ /// It has a one column
+ /// \param theParent a parent model index
+ virtual int columnCount(const QModelIndex &theParent = QModelIndex()) const;
+
+ /// Returns the index of the item in the model specified by the given row, column and parent index.
+ /// \param theRow a row
+ /// \param theColumn a column
+ /// \param theParent a parent model index
virtual QModelIndex index(int theRow, int theColumn, const QModelIndex& theParent =
QModelIndex()) const;
+ /// Returns the parent of the model item with the given index.
+ /// If the item has no parent, an invalid QModelIndex is returned.
+ /// \param theIndex a model index
virtual QModelIndex parent(const QModelIndex& theIndex) const;
+ /// Returns true if parent has any children; otherwise returns false.
+ /// \param theParent a parent model index
virtual bool hasChildren(const QModelIndex& theParent = QModelIndex()) const;
//! Returns object by the given Model index.
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_PartDataModel(QObject* theParent);
virtual ~XGUI_PartDataModel();
// Reimpl from QAbstractItemModel
- virtual QVariant data(const QModelIndex& theIndex, int theRole) const;
- virtual QVariant headerData(int section, Qt::Orientation orientation,
- int role = Qt::DisplayRole) const;
- virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
- virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
+ /// Returns the data stored under the given role for the item referred to by the index.
+ /// \param theIndex a model index
+ /// \param theRole a data role (see Qt::ItemDataRole)
+ virtual QVariant data(const QModelIndex& theIndex, int theRole) const;
+ /// Returns the data for the given role and section in the header with the specified orientation.
+ /// \param theSection a section
+ /// \param theOrient an orientation
+ /// \param theRole a data role (see Qt::ItemDataRole)
+ virtual QVariant headerData(int theSection, Qt::Orientation theOrient,
+ int theRole = Qt::DisplayRole) const;
+
+ /// Returns the number of rows under the given parent. When the parent is valid it means that
+ /// rowCount is returning the number of children of parent.
+ /// \param theParent a parent model index
+ virtual int rowCount(const QModelIndex &theParent = QModelIndex()) const;
+
+ /// Returns the number of columns for the children of the given parent.
+ /// It has a one column
+ /// \param theParent a parent model index
+ virtual int columnCount(const QModelIndex &theParent = QModelIndex()) const;
+
+ /// Returns the index of the item in the model specified by the given row, column and parent index.
+ /// \param theRow a row
+ /// \param theColumn a column
+ /// \param theParent a parent model index
virtual QModelIndex index(int theRow, int theColumn, const QModelIndex& theParent =
QModelIndex()) const;
+ /// Returns the parent of the model item with the given index.
+ /// If the item has no parent, an invalid QModelIndex is returned.
+ /// \param theIndex a model index
virtual QModelIndex parent(const QModelIndex& theIndex) const;
+ /// Returns true if parent has any children; otherwise returns false.
+ /// \param theParent a parent model index
virtual bool hasChildren(const QModelIndex& theParent = QModelIndex()) const;
//! Returns object by the given Model index.
//! Returns document of the current part
DocumentPtr partDocument() const;
+ //! Returns defult number of rows
int getRowsNumber() const;
//! Types of QModelIndexes
class XGUI_EXPORT PostponeMessageQtEvent : public QEvent
{
public:
+ /// An event type
static QEvent::Type PostponeMessageQtEventType;
/// Constructor
//! Returns interface to Salome viewer
virtual ModuleBase_IViewer* viewer() const = 0;
+ //! Create preferences
virtual void createPreferences() = 0;
};
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent workshop
XGUI_SelectionMgr(XGUI_Workshop* theParent);
virtual ~XGUI_SelectionMgr();
+ /// Returns current selection
XGUI_Selection* selection() const
{
return mySelection;
void selectionChanged();
private slots:
+ /// Reaction on selectio0n in Object browser
void onObjectBrowserSelection();
+
+ /// Reaction on selectio0n in Viewer
void onViewerSelection();
private:
+ /// Reference to workshop
XGUI_Workshop* myWorkshop;
+
+ /// Current selection object
XGUI_Selection* mySelection;
};
\return directory part of the file path
*/
namespace XGUI_Tools {
+
+/**
+* Returns directory name from name of file
+* \param path a path to a file
+* \param isAbs is absolute or relative path
+*/
QString XGUI_EXPORT dir(const QString& path, bool isAbs = true);
/*!
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent object
XGUI_ViewerProxy(XGUI_Workshop* theParent);
//! Returns AIS_InteractiveContext from current OCCViewer
}
//**************************************************************
-void XGUI_Workshop::activateLastPart()
-{
- SessionPtr aMgr = ModelAPI_Session::get();
- DocumentPtr aDoc = aMgr->moduleDocument();
- std::string aGrpName = ModelAPI_ResultPart::group();
- ObjectPtr aLastPart = aDoc->object(aGrpName, aDoc->size(aGrpName) - 1);
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aLastPart);
- if (aPart) {
- activatePart(aPart);
- }
-}
+//void XGUI_Workshop::activateLastPart()
+//{
+// SessionPtr aMgr = ModelAPI_Session::get();
+// DocumentPtr aDoc = aMgr->moduleDocument();
+// std::string aGrpName = ModelAPI_ResultPart::group();
+// ObjectPtr aLastPart = aDoc->object(aGrpName, aDoc->size(aGrpName) - 1);
+// ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aLastPart);
+// if (aPart) {
+// activatePart(aPart);
+// }
+//}
//**************************************************************
void XGUI_Workshop::deleteObjects(const QObjectPtrList& theList)
{
Q_OBJECT
public:
-
+ /// Constructor
+ /// \param theConnector a Salome connector object.
+ /// Used only if the workshop is launched in Salome environment
XGUI_Workshop(XGUI_SalomeConnector* theConnector = 0);
virtual ~XGUI_Workshop();
return myObjectBrowser;
}
+ /// This method is called by Salome module when selection is changed
void salomeViewerSelectionChanged();
+ /// Returns viewer which unifies access as to Salome viewer as to standalone viewer
XGUI_ViewerProxy* viewer() const
{
return myViewerProxy;
//! Show the given features in 3d Viewer
void showOnlyObjects(const QObjectPtrList& theList);
+ /// Set display mode for the given onjects
+ /// \param theList a list of displayed objects
+ /// \param theMode a mode to set (see \ref XGUI_Displayer)
void setDisplayMode(const QObjectPtrList& theList, int theMode);
+ /// Returns current module
ModuleBase_IModule* module() const
{
return myModule;
*/
void saveDocument(const QString& theName, std::list<std::string>& theFileNames);
- /*
+ /**
* If there is an active (uncommited) operation shows a prompt to abort it
* and performs abortion if user agreed. Returns true if
* - operation aborted successfully
bool isActiveOperationAborted();
signals:
+ /// Emitted when selection happens in Salome viewer
void salomeViewerSelection();
+
+ /// Emitted when error in applivation happens
void errorOccurred(const QString&);
+
//! the signal about the workshop actions states are updated.
void commandStatusUpdated();
void applicationStarted();
public slots:
+ /// Update of commands status
void updateCommandStatus();
+ /// Create a new dokument
void onNew();
+
+ /// Open document from file
void onOpen();
+
+ /// Save current document
bool onSave();
+
+ /// Save current document to a file selected by user
bool onSaveAs();
+
+ /// Exit application
void onExit();
+
+ /// Undo last command
void onUndo();
+
+ /// Redo previous command
void onRedo();
+
+ /// Rebuild data tree
void onRebuild();
+
+ /// Open preferences dialog box
void onPreferences();
+ /// Show property panel
void showPropertyPanel();
+
+ /// Hide property panel
void hidePropertyPanel();
+
+ /// Show object Browser
void showObjectBrowser();
+
+ /// Hide object Browser
void hideObjectBrowser();
+ /// Reaction on command call
void onFeatureTriggered();
+
+ /// Change active document
+ /// \param theObj a part object. If it is NULL then active document is a main document
void changeCurrentDocument(ObjectPtr theObj);
- void activateLastPart();
+ //void activateLastPart();
+ /// Close document
void closeDocument();
protected:
- // Find the nested features and set them into the operation
- // \param theOperation an operation
+ /// Find the nested features and set them into the operation
+ /// \param theOperation an operation
void setNestedFeatures(ModuleBase_Operation* theOperation);
- // Update the property panel content by the XML description of the operation and set the panel
- // into the operation
- // \param theOperation an operation
+
+ /// Update the property panel content by the XML description of the operation and set the panel
+ /// into the operation
+ /// \param theOperation an operation
void setPropertyPanel(ModuleBase_Operation* theOperation);
+ /// Procedure to process postponed events
bool event(QEvent * theEvent);
+
//Event-loop processing methods:
+
+ /// Process event "Add a feature"
void addFeature(const std::shared_ptr<Config_FeatureMessage>&);
+
+ /// Connect to operation signals
+ /// \param theOperation an operation
void connectWithOperation(ModuleBase_Operation* theOperation);
- void onFeatureUpdatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg);
- void onFeatureCreatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg);
- void onFeatureRedisplayMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg);
- void onObjectDeletedMsg(const std::shared_ptr<ModelAPI_ObjectDeletedMessage>& theMsg);
+ /// Process feature update message
+ void onFeatureUpdatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& );
- void validateOperation(const QString& theOperationId);
+ ///Process feature created message
+ void onFeatureCreatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& );
+ /// Process feature redisplay message
+ void onFeatureRedisplayMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& );
+
+ /// Process feature delete message
+ void onObjectDeletedMsg(const std::shared_ptr<ModelAPI_ObjectDeletedMessage>& );
+
+ /// Display all results
void displayAllResults();
+
+ /// Displau results from document
+ /// \param theDoc a document
void displayDocumentResults(DocumentPtr theDoc);
+
+ /// Display results from a group
void displayGroupResults(DocumentPtr theDoc, std::string theGroup);
private slots:
/// \param theOpertion an aborted operation
void onOperationAborted(ModuleBase_Operation* theOperation);
+ /// Process context menu command
+ /// \param theId id of the command
+ /// \param isChecked is checked flag
void onContextMenuCommand(const QString& theId, bool isChecked);
+ /// Processing of values changed in model widget
void onWidgetValuesChanged();
+ /// Set waiting cursor
void onStartWaiting();
private:
+ /// Init menu
void initMenu();
+ /// Register validators
void registerValidators() const;
+ /// Load module from external library
+ /// \param theModule name of the module
ModuleBase_IModule* loadModule(const QString& theModule);
+
+ /// Activate module
bool activateModule();
+ /// Create object browser widget
+ /// \param theParent a parent of widget
QDockWidget* createObjectBrowser(QWidget* theParent);
+
+ /// Create property panel widget
+ /// \param theParent a parent of widget
QDockWidget* createPropertyPanel(QWidget* theParent);
// Creates Dock widgets: Object browser and Property panel
