#include "ModuleBase_IModule.h"
+#include "ModuleBase_IViewer.h"
#include "ModuleBase_ViewerPrs.h"
#include "ModuleBase_Operation.h"
#include "ModuleBase_ISelection.h"
#include <Config_PointerMessage.h>
+ModuleBase_IModule::ModuleBase_IModule(ModuleBase_IWorkshop* theParent)
+ : QObject(theParent), myWorkshop(theParent)
+{
+ connect(myWorkshop, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
+ connect(myWorkshop->viewer(), SIGNAL(mousePress(QMouseEvent*)), this,
+ SLOT(onMousePressed(QMouseEvent*)));
+ connect(myWorkshop->viewer(), SIGNAL(mouseRelease(QMouseEvent*)), this,
+ SLOT(onMouseReleased(QMouseEvent*)));
+ connect(myWorkshop->viewer(), SIGNAL(mouseMove(QMouseEvent*)), this,
+ SLOT(onMouseMoved(QMouseEvent*)));
+ connect(myWorkshop->viewer(), SIGNAL(keyRelease(QKeyEvent*)), this,
+ SLOT(onKeyRelease(QKeyEvent*)));
+ connect(myWorkshop->viewer(), SIGNAL(mouseDoubleClick(QMouseEvent*)), this,
+ SLOT(onMouseDoubleClick(QMouseEvent*)));
+}
+
+
void ModuleBase_IModule::launchOperation(const QString& theCmdId)
{
ModuleBase_Operation* anOperation = createOperation(theCmdId.toStdString());
ModuleBase_ISelection* aSelection = myWorkshop->selection();
// Initialise operation with preliminary selection
- std::list<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- std::list<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
- anOperation->initSelection(aSelected, aHighlighted);
+ anOperation->initSelection(aSelection);
sendOperation(anOperation);
}
-#ifndef ModuleBase_IModule_H\r
-#define ModuleBase_IModule_H\r
-\r
+#ifndef ModuleBase_IModule_H
+#define ModuleBase_IModule_H
+
#include "ModuleBase.h"
-#include "ModuleBase_IWorkshop.h"\r
-\r
-#include <QString>\r
-#include <QObject>\r
-\r
-\r
-class QAction;\r
-class Config_WidgetAPI;\r
-class ModuleBase_ModelWidget;\r
-class ModuleBase_Operation;\r
-class ModuleBase_IWorkshop;\r
-\r
-/**\r
- * Interface to a module\r
- */\r
-class MODULEBASE_EXPORT ModuleBase_IModule : public QObject\r
-{\r
- public:\r
-\r
- ModuleBase_IModule(ModuleBase_IWorkshop* theParent): QObject(theParent), myWorkshop(theParent) {}\r
-\r
- virtual ~ModuleBase_IModule() {}\r
-\r
- /// Reads description of features from XML file \r
- virtual void createFeatures() = 0;\r
-\r
- /// Called on creation of menu item in desktop\r
- virtual void featureCreated(QAction*) = 0;\r
-\r
- /// Creates an operation and send it to loop\r
- /// \param theCmdId the operation name\r
- virtual void launchOperation(const QString& theCmdId);\r
-\r
- /// Called when it is necessary to update a command state (enable or disable it)\r
- //virtual bool isFeatureEnabled(const QString& theCmdId) const = 0;\r
-\r
- /// Creates custom widgets for property panel\r
- virtual QWidget* createWidgetByType(const std::string& theType, QWidget* theParent,\r
- Config_WidgetAPI* theWidgetApi,\r
- QList<ModuleBase_ModelWidget*>& theModelWidgets)\r
- {\r
- return 0;\r
- }\r
-\r
- ModuleBase_IWorkshop* workshop() const { return myWorkshop; }\r
-\r
- protected:\r
- /// Sends the operation for launching\r
- /// \param theOperation the operation\r
- void sendOperation(ModuleBase_Operation* theOperation);\r
-\r
- /// Creates a new operation\r
- /// \param theCmdId the operation name\r
- /// \param theFeatureKind a kind of feature to get the feature xml description\r
- virtual ModuleBase_Operation* createOperation(const std::string& theCmdId,\r
- const std::string& theFeatureKind = "") = 0;\r
-\r
-\r
-protected:\r
-\r
- ModuleBase_IWorkshop* myWorkshop;\r
-\r
-};\r
-\r
-//! This function must return a new module instance.\r
-extern "C" {\r
-typedef ModuleBase_IModule* (*CREATE_FUNC)(ModuleBase_IWorkshop*);\r
-}\r
-\r
-#define CREATE_MODULE "createModule"\r
-\r
-#endif //ModuleBase_IModule\r
+#include "ModuleBase_IWorkshop.h"
+
+#include <QString>
+#include <QObject>
+
+
+class QAction;
+class QMouseEvent;\r
+class QKeyEvent;\r
+class Config_WidgetAPI;
+class ModuleBase_ModelWidget;
+class ModuleBase_Operation;
+class ModuleBase_IWorkshop;
+
+/**
+ * Interface to a module
+ */
+class MODULEBASE_EXPORT ModuleBase_IModule : public QObject
+{
+ Q_OBJECT
+ public:
+
+ ModuleBase_IModule(ModuleBase_IWorkshop* theParent);
+
+ virtual ~ModuleBase_IModule() {}
+
+ /// Reads description of features from XML file
+ virtual void createFeatures() = 0;
+
+ /// Called on creation of menu item in desktop
+ virtual void featureCreated(QAction*) = 0;
+
+ /// Creates an operation and send it to loop
+ /// \param theCmdId the operation name
+ virtual void launchOperation(const QString& theCmdId);
+
+ /// Called when it is necessary to update a command state (enable or disable it)
+ //virtual bool isFeatureEnabled(const QString& theCmdId) const = 0;
+
+ /// Creates custom widgets for property panel
+ virtual QWidget* createWidgetByType(const std::string& theType, QWidget* theParent,
+ Config_WidgetAPI* theWidgetApi,
+ QList<ModuleBase_ModelWidget*>& theModelWidgets)
+ {
+ return 0;
+ }
+
+ ModuleBase_IWorkshop* workshop() const { return myWorkshop; }
+
+protected slots:
+
+ /// Called on selection changed event
+ virtual void onSelectionChanged() {}
+
+ /// SLOT, that is called by mouse press in the viewer.\r
+ /// The mouse released point is sent to the current operation to be processed.\r
+ /// \param theEvent the mouse event\r
+ virtual void onMousePressed(QMouseEvent* theEvent) {}\r
+\r
+ /// SLOT, that is called by mouse release in the viewer.\r
+ /// The mouse released point is sent to the current operation to be processed.\r
+ /// \param theEvent the mouse event\r
+ virtual void onMouseReleased(QMouseEvent* theEvent) {}\r
+ \r
+ /// SLOT, that is called by mouse move in the viewer.\r
+ /// The mouse moved point is sent to the current operation to be processed.\r
+ /// \param theEvent the mouse event\r
+ virtual void onMouseMoved(QMouseEvent* theEvent) {}\r
+\r
+ /// SLOT, that is called by the mouse double click in the viewer.\r
+ /// \param theEvent the mouse event\r
+ virtual void onMouseDoubleClick(QMouseEvent* theEvent) {}\r
+\r
+ /// SLOT, that is called by the key in the viewer is clicked.\r
+ /// \param theEvent the mouse event\r
+ virtual void onKeyRelease(QKeyEvent* theEvent) {}\r
+
+ protected:
+ /// Sends the operation for launching
+ /// \param theOperation the operation
+ void sendOperation(ModuleBase_Operation* theOperation);
+
+ /// Creates a new operation
+ /// \param theCmdId the operation name
+ /// \param theFeatureKind a kind of feature to get the feature xml description
+ virtual ModuleBase_Operation* createOperation(const std::string& theCmdId,
+ const std::string& theFeatureKind = "") = 0;
+
+
+protected:
+
+ ModuleBase_IWorkshop* myWorkshop;
+
+};
+
+//! This function must return a new module instance.
+extern "C" {
+typedef ModuleBase_IModule* (*CREATE_FUNC)(ModuleBase_IWorkshop*);
+}
+
+#define CREATE_MODULE "createModule"
+
+#endif //ModuleBase_IModule
/// Returns currently active widget
virtual ModuleBase_ModelWidget* activeWidget() const = 0;
+ /// Returns all property panel's widget created by WidgetFactory
+ virtual const QList<ModuleBase_ModelWidget*>& modelWidgets() const = 0;
+
signals:
/// The signal about key release on the control, that corresponds to the attribute
/// \param theEvent key release event
#include <NCollection_List.hxx>
#include <TopoDS_Shape.hxx>
-#include <list>
+#include <QList>
class ModuleBase_ISelection
{
/// Returns a list of viewer selected presentations
/// \param theShapeTypeToSkip the shapes with this type will be skipped during the result list build
/// \return list of presentations
- virtual std::list<ModuleBase_ViewerPrs> getSelected(int theShapeTypeToSkip = -1) const = 0;
+ virtual QList<ModuleBase_ViewerPrs> getSelected(int theShapeTypeToSkip = -1) const = 0;
/// Returns a list of viewer highlited presentations
/// \param theShapeTypeToSkip the shapes with this type will be skipped during the result list build
/// \return list of presentations
- virtual std::list<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const = 0;
+ virtual QList<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const = 0;
/**
* Returns list of features currently selected in 3d viewer
//! Returns data object by AIS
virtual ObjectPtr findPresentedObject(const AISObjectPtr& theAIS) const = 0;
+ //! Select features clearing previous selection.
+ //! If the list is empty then selection will be cleared
+ virtual void setSelected(const QList<ObjectPtr>& theFeatures) = 0;
+
signals:
void selectionChanged();
#include "ModuleBase_WidgetValueFeature.h"
#include "ModuleBase_ViewerPrs.h"
#include "ModuleBase_IPropertyPanel.h"
+#include "ModuleBase_ISelection.h"
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_Document.h>
}
}
-void ModuleBase_Operation::activateByPreselection()
+bool ModuleBase_Operation::activateByPreselection()
{
if (!myPropertyPanel)
- return;
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- if ((myPreSelection.size() > 0) && aActiveWgt) {
- const ModuleBase_ViewerPrs& aPrs = myPreSelection.front();
+ return false;
+ if (myPreSelection.empty())
+ return false;
+ const QList<ModuleBase_ModelWidget*>& aWidgets = myPropertyPanel->modelWidgets();
+ if (aWidgets.empty())
+ return false;
+
+ ModuleBase_ModelWidget* aWgt;
+ ModuleBase_ViewerPrs aPrs;
+ QList<ModuleBase_ModelWidget*>::const_iterator aWIt;
+ QList<ModuleBase_ViewerPrs>::const_iterator aPIt;
+ for (aWIt = aWidgets.constBegin(), aPIt = myPreSelection.constBegin();
+ (aWIt != aWidgets.constEnd()) && (aPIt != myPreSelection.constEnd());
+ ++aWIt, ++aPIt) {
+ aWgt = (*aWIt);
+ aPrs = (*aPIt);
ModuleBase_WidgetValueFeature aValue;
aValue.setObject(aPrs.object());
- if (aActiveWgt->setValue(&aValue)) {
- myPreSelection.remove(aPrs);
- myPropertyPanel->activateNextWidget();
- }
- // If preselection is enough to make a valid feature - apply it immediately
+ if (!aWgt->setValue(&aValue))
+ break;
}
+ if (canBeCommitted()) {
+ // if all widgets are filled with selection
+ commit();
+ return true;
+ }
+
+ //ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
+ //if ((myPreSelection.size() > 0) && aActiveWgt) {
+ // const ModuleBase_ViewerPrs& aPrs = myPreSelection.first();
+ // ModuleBase_WidgetValueFeature aValue;
+ // aValue.setObject(aPrs.object());
+ // if (aActiveWgt->setValue(&aValue)) {
+ // myPreSelection.removeOne(aPrs);
+ // myPropertyPanel->activateNextWidget();
+ // }
+ // // If preselection is enough to make a valid feature - apply it immediately
+ //}
+ return false;
}
-void ModuleBase_Operation::initSelection(
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& /*theHighlighted*/)
+void ModuleBase_Operation::initSelection(ModuleBase_ISelection* theSelection)
{
- myPreSelection = theSelected;
+ myPreSelection = theSelection->getSelected();
}
void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
{
- activateByPreselection();
+ //activateByPreselection();
//if (theWidget && myPropertyPanel) {
// myPropertyPanel->activateNextWidget();
//// //emit activateNextWidget(myActiveWidget);
#include <QObject>
#include <QString>
#include <QStringList>
+#include <List>
class ModuleBase_ModelWidget;
class ModuleBase_OperationDescription;
class ModuleBase_IPropertyPanel;
+class ModuleBase_ISelection;
class QKeyEvent;
/// Initialisation of operation with preliminary selection
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void initSelection(const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void initSelection(ModuleBase_ISelection* theSelection);
virtual void setPropertyPanel(ModuleBase_IPropertyPanel* theProp);
ModuleBase_IPropertyPanel* propertyPanel() const { return myPropertyPanel; }
+ /// Activates widgets by preselection if it is accepted
+ virtual bool activateByPreselection();
+
signals:
void started(); /// the operation is started
void aborted(); /// the operation is aborted
/// Returns pointer to the root document.
boost::shared_ptr<ModelAPI_Document> document() const;
- /// Activates widgets by preselection if it is accepted
- virtual void activateByPreselection();
-
/// Set value to the active widget
/// \param theFeature the feature
/// \param theX the horizontal coordinate
QStringList myNestedFeatures;
/// List of pre-selected object
- std::list<ModuleBase_ViewerPrs> myPreSelection;
+ QList<ModuleBase_ViewerPrs> myPreSelection;
/// Access to property panel
ModuleBase_IPropertyPanel* myPropertyPanel;
const Standard_Integer theMode)
{
boost::shared_ptr<GeomAPI_Shape> aShapePtr = ModelAPI_Tools::shape(myResult);
+ if (!aShapePtr)
+ return;
myOriginalShape = aShapePtr->impl<TopoDS_Shape>();
Set(aShapePtr->impl<TopoDS_Shape>());
AIS_Shape::Compute(thePresentationManager, thePresentation, theMode);
ModuleBase_WidgetFactory::~ModuleBase_WidgetFactory()
{
+ delete myWidgetApi;
}
void ModuleBase_WidgetFactory::createWidget(QWidget* theParent)
connect(aContextMenuMgr, SIGNAL(actionTriggered(const QString&, bool)), this,
SLOT(onContextMenuCommand(const QString&, bool)));
- connect(myWorkshop->viewer(), SIGNAL(mousePress(QMouseEvent*)), this,
- SLOT(onMousePressed(QMouseEvent*)));
- connect(myWorkshop->viewer(), SIGNAL(mouseRelease(QMouseEvent*)), this,
- SLOT(onMouseReleased(QMouseEvent*)));
- connect(myWorkshop->viewer(), SIGNAL(mouseMove(QMouseEvent*)), this,
- SLOT(onMouseMoved(QMouseEvent*)));
- connect(myWorkshop->viewer(), SIGNAL(keyRelease(QKeyEvent*)), this,
- SLOT(onKeyRelease(QKeyEvent*)));
- connect(myWorkshop->viewer(), SIGNAL(mouseDoubleClick(QMouseEvent*)), this,
- SLOT(onMouseDoubleClick(QMouseEvent*)));
}
PartSet_Module::~PartSet_Module()
XGUI_Workshop* aXWshp = xWorkshop();
PartSet_OperationSketchBase* aPreviewOp =
dynamic_cast<PartSet_OperationSketchBase*>(workshop()->currentOperation());
- Handle(V3d_View) aView = myWorkshop->viewer()->activeView();
- if (aPreviewOp && (!aView.IsNull())) {
+ if (aPreviewOp) {
ModuleBase_ISelection* aSelection = workshop()->selection();
// Initialise operation with preliminary selection
- std::list<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- std::list<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
-
- aPreviewOp->mousePressed(theEvent, aView, aSelected, aHighlighted);
+ //QList<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
+ //QList<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
+ //QList<ObjectPtr> aObjList;
+ //bool aHasShift = (theEvent->modifiers() & Qt::ShiftModifier);
+ //if (aHasShift) {
+ // foreach(ModuleBase_ViewerPrs aPrs, aSelected)
+ // aObjList.append(aPrs.object());
+
+ // foreach (ModuleBase_ViewerPrs aPrs, aHighlighted) {
+ // if (!aObjList.contains(aPrs.object()))
+ // aObjList.append(aPrs.object());
+ // }
+ //} else {
+ // foreach(ModuleBase_ViewerPrs aPrs, aHighlighted)
+ // aObjList.append(aPrs.object());
+ //}
+ //onSetSelection(aObjList);
+ aPreviewOp->mousePressed(theEvent, myWorkshop->viewer(), aSelection);
}
}
{
PartSet_OperationSketchBase* aPreviewOp =
dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- Handle(V3d_View) aView = myWorkshop->viewer()->activeView();
- if (aPreviewOp && (!aView.IsNull())) {
+ if (aPreviewOp) {
ModuleBase_ISelection* aSelection = workshop()->selection();
// Initialise operation with preliminary selection
- std::list<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- std::list<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
-
- aPreviewOp->mouseReleased(theEvent, aView, aSelected, aHighlighted);
+ aPreviewOp->mouseReleased(theEvent, myWorkshop->viewer(), aSelection);
}
}
{
PartSet_OperationSketchBase* aPreviewOp =
dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- Handle(V3d_View) aView = myWorkshop->viewer()->activeView();
- if (aPreviewOp && (!aView.IsNull()))
- aPreviewOp->mouseMoved(theEvent, aView);
+ if (aPreviewOp)
+ aPreviewOp->mouseMoved(theEvent, myWorkshop->viewer());
}
void PartSet_Module::onKeyRelease(QKeyEvent* theEvent)
if (aPreviewOp && (!aView.IsNull())) {
ModuleBase_ISelection* aSelection = workshop()->selection();
// Initialise operation with preliminary selection
- std::list<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- std::list<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
- aPreviewOp->mouseDoubleClick(theEvent, aView, aSelected, aHighlighted);
+ aPreviewOp->mouseDoubleClick(theEvent, aView, aSelection);
}
}
}
ModuleBase_ISelection* aSelection = workshop()->selection();
// Initialise operation with preliminary selection
- std::list<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
- std::list<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
- aSketchOp->initSelection(aSelected, aHighlighted);
+ aSketchOp->initSelection(aSelection);
} //else if (aFeature) {
//anOperation->setFeature(aFeature);
////Deactivate result of current feature in order to avoid its selection
SLOT(onFeatureConstructed(ObjectPtr, int)));
connect(aPreviewOp, SIGNAL(restartRequired(std::string, ObjectPtr)), this,
SLOT(onRestartOperation(std::string, ObjectPtr)));
- connect(aPreviewOp, SIGNAL(multiSelectionEnabled(bool)), this,
- SLOT(onMultiSelectionEnabled(bool)));
+ // If manage multi selection the it will be impossible to select more then one
+ // object under operation Edit
+// connect(aPreviewOp, SIGNAL(multiSelectionEnabled(bool)), this,
+// SLOT(onMultiSelectionEnabled(bool)));
connect(aPreviewOp, SIGNAL(stopSelection(const QList<ObjectPtr>&, const bool)), this,
SLOT(onStopSelection(const QList<ObjectPtr>&, const bool)));
return gp_Pln(aOrig, aDir);
}
+
+void PartSet_Module::onSelectionChanged()
+{
+ ModuleBase_ISelection* aSelect = myWorkshop->selection();
+ QList<ModuleBase_ViewerPrs> aSelected = aSelect->getSelected();
+ // We need to stop edit operation if selection is cleared
+ if (aSelected.size() == 0) {
+ PartSet_OperationFeatureEdit* anEditOp =
+ dynamic_cast<PartSet_OperationFeatureEdit*>(myWorkshop->currentOperation());
+ if (!anEditOp)
+ return;
+ anEditOp->commit();
+ } else {
+ PartSet_OperationSketchBase* aSketchOp =
+ dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
+ if (aSketchOp) {
+ aSketchOp->selectionChanged(aSelect);
+ }
+ }
+}
#include <boost/shared_ptr.hpp>
-class QMouseEvent;
-class QKeyEvent;
class PartSet_Listener;
class ModelAPI_Feature;
class XGUI_ViewerPrs;
void onOperationStopped(ModuleBase_Operation* theOperation);
/// SLOT, that is called afetr the popup menu action clicked.
void onContextMenuCommand(const QString& theId, bool isChecked);
- /// SLOT, that is called by mouse press in the viewer.
- /// The mouse released point is sent to the current operation to be processed.
- /// \param theEvent the mouse event
- void onMousePressed(QMouseEvent* theEvent);
- /// SLOT, that is called by mouse release in the viewer.
- /// The mouse released point is sent to the current operation to be processed.
- /// \param theEvent the mouse event
- void onMouseReleased(QMouseEvent* theEvent);
- /// SLOT, that is called by mouse move in the viewer.
- /// The mouse moved point is sent to the current operation to be processed.
- /// \param theEvent the mouse event
- void onMouseMoved(QMouseEvent* theEvent);
-
- /// SLOT, that is called by the key in the viewer is clicked.
- /// \param theEvent the mouse event
- void onKeyRelease(QKeyEvent* theEvent);
-
- /// SLOT, that is called by the mouse double click in the viewer.
- /// \param theEvent the mouse event
- void onMouseDoubleClick(QMouseEvent* theEvent);
/// SLOT, to apply to the current viewer the operation
/// \param theX the X projection value
/// \param the attribute of the feature
void onStorePoint2D(ObjectPtr theFeature, const std::string& theAttribute);
+protected slots:
+ /// Called on selection changed event
+ virtual void onSelectionChanged();
+
+ /// SLOT, that is called by mouse press in the viewer.
+ /// The mouse released point is sent to the current operation to be processed.
+ /// \param theEvent the mouse event
+ virtual void onMousePressed(QMouseEvent* theEvent);
+
+ /// SLOT, that is called by mouse release in the viewer.
+ /// The mouse released point is sent to the current operation to be processed.
+ /// \param theEvent the mouse event
+ virtual void onMouseReleased(QMouseEvent* theEvent);
+
+ /// SLOT, that is called by mouse move in the viewer.
+ /// The mouse moved point is sent to the current operation to be processed.
+ /// \param theEvent the mouse event
+ virtual void onMouseMoved(QMouseEvent* theEvent);
+
+ /// SLOT, that is called by the mouse double click in the viewer.
+ /// \param theEvent the mouse event
+ virtual void onMouseDoubleClick(QMouseEvent* theEvent);
+
+ /// SLOT, that is called by the key in the viewer is clicked.
+ /// \param theEvent the mouse event
+ virtual void onKeyRelease(QKeyEvent* theEvent);
+
protected:
/// Creates a new operation
/// \param theCmdId the operation name
#include <ModuleBase_WidgetPoint2D.h>
#include <ModuleBase_WidgetValueFeature.h>
#include "ModuleBase_IPropertyPanel.h"
+#include "ModuleBase_ISelection.h"
+#include "ModuleBase_IViewer.h"
#include <XGUI_Constants.h>
return mySketch;
}
-void PartSet_OperationFeatureBase::mouseReleased(QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& /*theHighlighted*/)
+void PartSet_OperationFeatureBase::mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
- gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
+ Handle(V3d_View) aView = theViewer->activeView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
double aX = aPoint.X(), anY = aPoint.Y();
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- if (theSelected.empty()) {
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ if (aSelected.empty()) {
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
} else {
- ModuleBase_ViewerPrs aPrs = theSelected.front();
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
const TopoDS_Shape& aShape = aPrs.shape();
if (!aShape.IsNull()) {
if (aShape.ShapeType() == TopAbs_VERTEX) { // a point is selected
const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape);
if (!aVertex.IsNull()) {
aPoint = BRep_Tool::Pnt(aVertex);
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
PartSet_Tools::setConstraints(sketch(), feature(), aActiveWgt->attributeID(), aX, anY);
}
} else if (aShape.ShapeType() == TopAbs_EDGE) { // a line is selected
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
}
}
}
ObjectPtr aFeature;
- if (!theSelected.empty()) {
- ModuleBase_ViewerPrs aPrs = theSelected.front();
+ if (!aSelected.empty()) {
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
aFeature = aPrs.object();
} else {
aFeature = feature(); // for the widget distance only
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
protected:
#include <ModuleBase_WidgetValueFeature.h>
#include <ModuleBase_ViewerPrs.h>
#include <ModuleBase_IPropertyPanel.h>
+#include <ModuleBase_ISelection.h>
+#include <ModuleBase_IViewer.h>
#include <XGUI_Constants.h>
return false;
}
-void PartSet_OperationFeatureCreate::mouseMoved(QMouseEvent* theEvent, Handle(V3d_View) theView)
+void PartSet_OperationFeatureCreate::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
{
double aX, anY;
- gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ Handle(V3d_View) aView = theViewer->activeView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
setWidgetValue(feature(), aX, anY);
flushUpdated();
}
}
}
-void PartSet_OperationFeatureCreate::mouseReleased(QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& /*theHighlighted*/)
+void PartSet_OperationFeatureCreate::mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
- gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
+ Handle(V3d_View) aView = theViewer->activeView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
double aX = aPoint.X(), anY = aPoint.Y();
bool isClosedContour = false;
- if (theSelected.empty()) {
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+
+ if (aSelected.empty()) {
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
} else {
- ModuleBase_ViewerPrs aPrs = theSelected.front();
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
const TopoDS_Shape& aShape = aPrs.shape();
if (!aShape.IsNull()) {
if (aShape.ShapeType() == TopAbs_VERTEX) { // a point is selected
const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape);
if (!aVertex.IsNull()) {
aPoint = BRep_Tool::Pnt(aVertex);
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
PartSet_Tools::setConstraints(sketch(), feature(), aActiveWgt->attributeID(), aX, anY);
isClosedContour = true;
}
} else if (aShape.ShapeType() == TopAbs_EDGE) { // a line is selected
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
}
}
}
ObjectPtr aFeature;
- if (!theSelected.empty()) {
- ModuleBase_ViewerPrs aPrs = theSelected.front();
+ if (!aSelected.empty()) {
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
aFeature = aPrs.object();
} else {
aFeature = feature(); // for the widget distance only
void PartSet_OperationFeatureCreate::startOperation()
{
PartSet_OperationSketchBase::startOperation();
- emit multiSelectionEnabled(false);
+ //emit multiSelectionEnabled(false);
}
void PartSet_OperationFeatureCreate::abortOperation()
void PartSet_OperationFeatureCreate::stopOperation()
{
PartSet_OperationSketchBase::stopOperation();
- emit multiSelectionEnabled(true);
+ //emit multiSelectionEnabled(true);
}
void PartSet_OperationFeatureCreate::afterCommitOperation()
/// Gives the current mouse point in the viewer
/// \param thePoint a point clicked in the viewer
/// \param theEvent the mouse event
- virtual void mouseMoved(QMouseEvent* theEvent, Handle_V3d_View theView);
+ virtual void mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer);
/// Gives the current selected objects to be processed by the operation
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
/// Processes the key pressed in the view
/// \param theKey a key value
virtual void keyReleased(const int theKey);
#include <PartSet_OperationFeatureEdit.h>
#include <PartSet_Tools.h>
#include <PartSet_OperationSketch.h>
+#include <PartSet_OperationFeatureEditMulti.h>
#include <SketchPlugin_Constraint.h>
#include <ModuleBase_WidgetEditor.h>
#include <ModuleBase_ViewerPrs.h>
#include <ModuleBase_IPropertyPanel.h>
+#include <ModuleBase_ISelection.h>
+#include <ModuleBase_IViewer.h>
#include <ModelAPI_Events.h>
}
-void PartSet_OperationFeatureEdit::mousePressed(QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+void PartSet_OperationFeatureEdit::mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection)
{
ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
if(aActiveWgt && aActiveWgt->isViewerSelector()) {
// Almost do nothing, all stuff in on PartSet_OperationFeatureBase::mouseReleased
- PartSet_OperationFeatureBase::mousePressed(theEvent, theView, theSelected, theHighlighted);
+ PartSet_OperationFeatureBase::mousePressed(theEvent, theViewer, theSelection);
return;
}
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+ QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
+ bool aHasShift = (theEvent->modifiers() & Qt::ShiftModifier);
+ if (aHasShift && !aHighlighted.empty()) {
+ foreach (ModuleBase_ViewerPrs aPrs, aHighlighted) {
+ aSelected.append(aPrs);
+ }
+ }
ObjectPtr aObject;
- if (!theHighlighted.empty())
- aObject = theHighlighted.front().object();
- if (!aObject && !theSelected.empty()) // changed for a constrain
- aObject = theSelected.front().object();
+ if (!aSelected.empty()) {
+ aObject = aSelected.first().object();
+ } else {
+ if (!aHighlighted.empty())
+ aObject = aHighlighted.first().object();
+ }
+ //if (!theHighlighted.empty())
+ // aObject = theHighlighted.front().object();
+ //if (!aObject && !theSelected.empty()) // changed for a constrain
+ // aObject = theSelected.front().object();
FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
- if (!aFeature || aFeature != feature()) {
+ if (!aFeature || aFeature != feature() || (aSelected.size() > 1)) {
if (commit()) {
+ theViewer->enableSelection(true);
emit featureConstructed(feature(), FM_Deactivation);
+ // If we have selection and prehilighting with shift pressed
+ // Then we have to select all these objects and restart as multi edit operfation
//bool aHasShift = (theEvent->modifiers() & Qt::ShiftModifier);
//if (aHasShift && !theHighlighted.empty()) {
// QList<ObjectPtr> aSelected;
// std::list<ModuleBase_ViewerPrs>::const_iterator aIt;
// for (aIt = theSelected.cbegin(); aIt != theSelected.cend(); ++aIt)
// aSelected.append((*aIt).object());
- /*for (aIt = theHighlighted.cbegin(); aIt != theHighlighted.cend(); ++aIt) {
- if (!aSelected.contains((*aIt).object()))
- aSelected.append((*aIt).object());
- }*/
- //aSelected.push_back(feature());
- //aSelected.push_back(theHighlighted.front().object());
- //emit setSelection(aSelected);
+
+ // for (aIt = theHighlighted.cbegin(); aIt != theHighlighted.cend(); ++aIt) {
+ // if (!aSelected.contains((*aIt).object()))
+ // aSelected.append((*aIt).object());
+ // }
+ // emit setSelection(aSelected);
//} else
if (aFeature) {
- restartOperation(PartSet_OperationFeatureEdit::Type(), aFeature);
+ std::string anOperationType =
+ (aSelected.size() > 1) ?
+ PartSet_OperationFeatureEditMulti::Type() : PartSet_OperationFeatureEdit::Type();
+ restartOperation(anOperationType, aFeature);
}
+ //}
}
}
}
-void PartSet_OperationFeatureEdit::mouseMoved(QMouseEvent* theEvent, Handle(V3d_View) theView)
+void PartSet_OperationFeatureEdit::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
{
if (!(theEvent->buttons() & Qt::LeftButton))
return;
+ Handle(V3d_View) aView = theViewer->activeView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
- gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
+ theViewer->enableSelection(false);
- blockSelection(true);
+ //blockSelection(true);
if (myCurPoint.myIsInitialized) {
double aCurX, aCurY;
- PartSet_Tools::convertTo2D(myCurPoint.myPoint, sketch(), theView, aCurX, aCurY);
+ PartSet_Tools::convertTo2D(myCurPoint.myPoint, sketch(), aView, aCurX, aCurY);
double aX, anY;
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
double aDeltaX = aX - aCurX;
double aDeltaY = anY - aCurY;
}
void PartSet_OperationFeatureEdit::mouseReleased(
- QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+ QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
+ theViewer->enableSelection(true);
ModuleBase_ModelWidget* aActiveWgt = 0;
if (myPropertyPanel)
aActiveWgt = myPropertyPanel->activeWidget();
if(aActiveWgt && aActiveWgt->isViewerSelector()) {
// Almost do nothing, all stuff in on PartSet_OperationFeatureBase::mouseReleased
- PartSet_OperationFeatureBase::mouseReleased(theEvent, theView, theSelected, theHighlighted);
- } else {
- blockSelection(false);
- }
+ PartSet_OperationFeatureBase::mouseReleased(theEvent, theViewer, theSelection);
+ }// else {
+ //blockSelection(false);
+ //}
}
void PartSet_OperationFeatureEdit::mouseDoubleClick(
QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+ ModuleBase_ISelection* theSelection)
{
// TODO the functionality is important only for constraint feature. Should be moved in another place
- if (!theSelected.empty()) {
- ModuleBase_ViewerPrs aFeaturePrs = theSelected.front();
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+ if (!aSelected.empty()) {
+ ModuleBase_ViewerPrs aFeaturePrs = aSelected.first();
if (!aFeaturePrs.owner().IsNull()) {
Handle(AIS_DimensionOwner) anOwner = Handle(AIS_DimensionOwner)::DownCast(
aFeaturePrs.owner());
void PartSet_OperationFeatureEdit::startOperation()
{
PartSet_OperationSketchBase::startOperation();
- emit multiSelectionEnabled(false);
+ //emit multiSelectionEnabled(false);
myCurPoint.clear();
}
void PartSet_OperationFeatureEdit::stopOperation()
{
- emit multiSelectionEnabled(true);
+ //emit multiSelectionEnabled(true);
- blockSelection(false, false);
+ //blockSelection(false, false);
}
-void PartSet_OperationFeatureEdit::blockSelection(bool isBlocked, const bool isRestoreSelection)
-{
- if (myIsBlockedSelection == isBlocked)
- return;
-
- myIsBlockedSelection = isBlocked;
- QList<ObjectPtr> aFeatureList;
- aFeatureList.append(feature());
-
- if (isBlocked) {
- emit setSelection(QList<ObjectPtr>());
- emit stopSelection(aFeatureList, true);
- } else {
- emit stopSelection(aFeatureList, false);
- if (isRestoreSelection)
- emit setSelection(aFeatureList);
- }
-}
+//void PartSet_OperationFeatureEdit::blockSelection(bool isBlocked, const bool isRestoreSelection)
+//{
+// if (myIsBlockedSelection == isBlocked)
+// return;
+//
+// myIsBlockedSelection = isBlocked;
+// QList<ObjectPtr> aFeatureList;
+// aFeatureList.append(feature());
+//
+// //if (isBlocked) {
+// // emit setSelection(QList<ObjectPtr>());
+// // emit stopSelection(aFeatureList, true);
+// //} else {
+// // emit stopSelection(aFeatureList, false);
+// // if (isRestoreSelection)
+// // emit setSelection(aFeatureList);
+// //}
+//}
FeaturePtr PartSet_OperationFeatureEdit::createFeature(const bool theFlushMessage,
CompositeFeaturePtr theCompositeFeature)
#include <QObject>
class QMouseEvent;
+class ModuleBase_ISelection;
/*!
\class PartSet_OperationFeatureEdit
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mousePressed(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection);
+
/// Gives the current mouse point in the viewer
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
- virtual void mouseMoved(QMouseEvent* theEvent, Handle_V3d_View theView);
+ virtual void mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer);
/// Gives the current selected objects to be processed by the operation
/// \param thePoint a point clicked in the viewer
/// \param theEvent the mouse event
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
/// Processes the mouse double click in the point
/// \param theEvent the mouse event
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
virtual void mouseDoubleClick(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ ModuleBase_ISelection* theSelection);
protected:
/// \brief Virtual method called when operation is started
/// the internal operation features are to be selected
/// \param isBlocked the state whether the operation is blocked or unblocked
/// \param isRestoreSelection the state whether the selected objects should be reselected
- void blockSelection(bool isBlocked, const bool isRestoreSelection = true);
+ //void blockSelection(bool isBlocked, const bool isRestoreSelection = true);
/// Sends the features
void sendFeatures();
#include <ModuleBase_OperationDescription.h>
#include <ModuleBase_ViewerPrs.h>
+#include <ModuleBase_IViewer.h>
+#include <ModuleBase_ISelection.h>
#include <ModelAPI_Events.h>
}
-bool isContains(const std::list<ModuleBase_ViewerPrs>& theSelected, const ModuleBase_ViewerPrs& thePrs)
+bool isContains(const QList<ModuleBase_ViewerPrs>& theSelected, const ModuleBase_ViewerPrs& thePrs)
{
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt;
- for (anIt = theSelected.cbegin(); anIt != theSelected.cend(); ++anIt) {
- if ((*anIt).object() == thePrs.object())
+ foreach (ModuleBase_ViewerPrs aPrs, theSelected) {
+ if (aPrs.object() == thePrs.object())
return true;
}
return false;
}
-void PartSet_OperationFeatureEditMulti::initSelection(
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+void PartSet_OperationFeatureEditMulti::initSelection(ModuleBase_ISelection* theSelection)
{
//if (!theHighlighted.empty()) {
// // if there is highlighted object, we check whether it is in the list of selected objects
// else
// myFeatures = theSelected;
//} else
- myFeatures = theSelected;
+ myFeatures = theSelection->getSelected();
+ QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
// add highlighted elements if they are not selected
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = theHighlighted.cbegin();
- for ( ; anIt != theHighlighted.cend(); ++anIt) {
- if (!isContains(myFeatures, (*anIt)))
- myFeatures.push_back(*anIt);
+ foreach (ModuleBase_ViewerPrs aPrs, aHighlighted) {
+ if (!isContains(myFeatures, aPrs))
+ myFeatures.append(aPrs);
}
// Remove current feature if it is in the list (it will be moved as main feature)
- std::list<ModuleBase_ViewerPrs>::iterator anEraseIt = myFeatures.begin();
- for ( ; anEraseIt != myFeatures.end(); ++anEraseIt) {
- if (ModelAPI_Feature::feature((*anEraseIt).object()) == feature()) {
- myFeatures.erase(anEraseIt);
+ foreach (ModuleBase_ViewerPrs aPrs, myFeatures) {
+ FeaturePtr aF = ModelAPI_Feature::feature(aPrs.object());
+ if (ModelAPI_Feature::feature(aPrs.object()) == feature()) {
+ myFeatures.removeOne(aPrs);
break;
}
}
return mySketch;
}
-void PartSet_OperationFeatureEditMulti::mousePressed(
- QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& /*theSelected*/,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
-{
-}
+//void PartSet_OperationFeatureEditMulti::mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection)
+//{
+//}
-void PartSet_OperationFeatureEditMulti::mouseMoved(QMouseEvent* theEvent, Handle(V3d_View) theView)
+void PartSet_OperationFeatureEditMulti::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
{
if (!(theEvent->buttons() & Qt::LeftButton))
return;
- gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
+ if (theViewer->isSelectionEnabled())
+ theViewer->enableSelection(false);
+
+ Handle(V3d_View) aView = theViewer->activeView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
- blockSelection(true);
+ //blockSelection(true);
if (myCurPoint.myIsInitialized) {
double aCurX, aCurY;
- PartSet_Tools::convertTo2D(myCurPoint.myPoint, sketch(), theView, aCurX, aCurY);
+ PartSet_Tools::convertTo2D(myCurPoint.myPoint, sketch(), aView, aCurX, aCurY);
double aX, anY;
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
+ PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
double aDeltaX = aX - aCurX;
double aDeltaY = anY - aCurY;
SketchPlugin_Feature>(feature());
aSketchFeature->move(aDeltaX, aDeltaY);
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = myFeatures.begin(),
- aLast = myFeatures.end();
- for (; anIt != aLast; anIt++) {
- ObjectPtr aObject = (*anIt).object();
+ foreach (ModuleBase_ViewerPrs aPrs, myFeatures) {
+ ObjectPtr aObject = aPrs.object();
if (!aObject || aObject == feature())
continue;
FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
}
void PartSet_OperationFeatureEditMulti::mouseReleased(
- QMouseEvent* theEvent, Handle(V3d_View) theView,
- const std::list<ModuleBase_ViewerPrs>& /*theSelected*/,
- const std::list<ModuleBase_ViewerPrs>& /*theHighlighted*/)
+ QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
+ theViewer->enableSelection(true);
if (commit()) {
- std::list<ModuleBase_ViewerPrs> aFeatures = myFeatures;
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = aFeatures.begin(), aLast =
- aFeatures.end();
- for (; anIt != aLast; anIt++) {
- ObjectPtr aFeature = (*anIt).object();
+ foreach (ModuleBase_ViewerPrs aPrs, myFeatures) {
+ ObjectPtr aFeature = aPrs.object();
if (aFeature) {
emit featureConstructed(aFeature, FM_Deactivation);
}
void PartSet_OperationFeatureEditMulti::startOperation()
{
PartSet_OperationSketchBase::startOperation();
- emit multiSelectionEnabled(false);
+ //emit multiSelectionEnabled(false);
- blockSelection(true);
+ //blockSelection(true);
myCurPoint.clear();
}
void PartSet_OperationFeatureEditMulti::stopOperation()
{
- emit multiSelectionEnabled(true);
+ //emit multiSelectionEnabled(true);
- blockSelection(false, true);
+ //blockSelection(false, true);
myFeatures.clear();
}
-void PartSet_OperationFeatureEditMulti::blockSelection(bool isBlocked,
- const bool isRestoreSelection)
-{
- if (myIsBlockedSelection == isBlocked)
- return;
-
- myIsBlockedSelection = isBlocked;
- QList<ObjectPtr> aFeatureList;
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = myFeatures.begin(), aLast =
- myFeatures.end();
- /*for(; anIt != aLast; anIt++)
- aFeatureList.append((*anIt).feature());*/
- if (isBlocked) {
- emit setSelection(QList<ObjectPtr>());
- emit stopSelection(aFeatureList, true);
- } else {
- emit stopSelection(aFeatureList, false);
- if (isRestoreSelection) {
- emit setSelection(aFeatureList);
- }
- }
-}
+//void PartSet_OperationFeatureEditMulti::blockSelection(bool isBlocked,
+// const bool isRestoreSelection)
+//{
+// if (myIsBlockedSelection == isBlocked)
+// return;
+//
+// myIsBlockedSelection = isBlocked;
+// QList<ObjectPtr> aFeatureList;
+//// std::list<ModuleBase_ViewerPrs>::const_iterator anIt = myFeatures.begin(), aLast =
+//// myFeatures.end();
+// /*for(; anIt != aLast; anIt++)
+// aFeatureList.append((*anIt).feature());*/
+// //if (isBlocked) {
+// // emit setSelection(QList<ObjectPtr>());
+// // emit stopSelection(aFeatureList, true);
+// //} else {
+// // emit stopSelection(aFeatureList, false);
+// // if (isRestoreSelection) {
+// // emit setSelection(aFeatureList);
+// // }
+// //}
+//}
void PartSet_OperationFeatureEditMulti::sendFeatures()
{
static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_MOVED);
- std::list<FeaturePtr> aFeatures;
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = myFeatures.begin(), aLast =
- myFeatures.end();
- for (; anIt != aLast; anIt++) {
- ObjectPtr aFeature = (*anIt).object();
+ foreach (ModuleBase_ViewerPrs aPrs, myFeatures) {
+ ObjectPtr aFeature = aPrs.object();
if (!aFeature)
continue;
#include <PartSet_OperationSketchBase.h>
#include <QObject>
+#include <QList>
#include <list>
/// Initialisation of operation with preliminary selection
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void initSelection(const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void initSelection(ModuleBase_ISelection* theSelection);
/// Returns the operation sketch feature
/// \returns the sketch instance
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mousePressed(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ //virtual void mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection);
+
/// Gives the current mouse point in the viewer
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
- virtual void mouseMoved(QMouseEvent* theEvent, Handle_V3d_View theView);
+ virtual void mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer);
+
/// Gives the current selected objects to be processed by the operation
/// \param thePoint a point clicked in the viewer
/// \param theEvent the mouse event
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
+
protected:
/// \brief Virtual method called when operation is started
/// Virtual method called when operation started (see start() method for more description)
/// the internal operation features are to be selected
/// \param isBlocked the state whether the operation is blocked or unblocked
/// \param isRestoreSelection the state whether the selected objects should be reselected
- void blockSelection(bool isBlocked, const bool isRestoreSelection = true);
+ //void blockSelection(bool isBlocked, const bool isRestoreSelection = true);
/// Sends the features
void sendFeatures();
private:
CompositeFeaturePtr mySketch; ///< the sketch feature
- std::list<ModuleBase_ViewerPrs> myFeatures; ///< the features to apply the edit operation
+ QList<ModuleBase_ViewerPrs> myFeatures; ///< the features to apply the edit operation
Point myCurPoint; ///< the current 3D point clicked or moved
bool myIsBlockedSelection; ///< the state of the last state of selection blocked signal
};
#include <GeomAPI_XYZ.h>
#include <ModuleBase_ViewerPrs.h>
+#include <ModuleBase_ISelection.h>
+#include <ModuleBase_IViewer.h>
#include <Events_Loop.h>
#include <AIS_Shape.hxx>
return boost::dynamic_pointer_cast<ModelAPI_CompositeFeature>(feature());
}
-void PartSet_OperationSketch::mousePressed(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+void PartSet_OperationSketch::mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection)
{
if (hasSketchPlane()) {
// if shift button is pressed and there are some already selected objects, the operation should
// not be started. We just want to combine some selected objects.
bool aHasShift = (theEvent->modifiers() & Qt::ShiftModifier);
- if (aHasShift && theSelected.size() > 0)
- return;
-
- if (theHighlighted.size() == 1) {
- ObjectPtr aFeature = theHighlighted.front().object();
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+ QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
+ //if (aHasShift && (aSelected.size() > 0)) {
+ foreach(ModuleBase_ViewerPrs aPrs, aHighlighted)
+ aSelected.append(aPrs);
+ //}
+ //if (aHasShift && aSelected.size() > 0)
+ // return;
+
+ if (aSelected.size() > 0) {
+ ObjectPtr aFeature = aSelected.first().object();
if (aFeature) {
std::string anOperationType =
- (theSelected.size() > 1) ?
+ (aSelected.size() > 1) ?
PartSet_OperationFeatureEditMulti::Type() : PartSet_OperationFeatureEdit::Type();
restartOperation(anOperationType, aFeature);
}
- } else
- myFeatures = theHighlighted;
-
- } else {
- if (!theHighlighted.empty()) {
- ModuleBase_ViewerPrs aPrs = theHighlighted.front();
- const TopoDS_Shape& aShape = aPrs.shape();
- if (!aShape.IsNull())
- setSketchPlane(aShape);
- }
+ } //else
+ //myFeatures = aSelected;
+
+ }
+}
+
+
+void PartSet_OperationSketch::selectionChanged(ModuleBase_ISelection* theSelection)
+{
+ if (hasSketchPlane())
+ return;
+
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+ if (!aSelected.empty()) {
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
+ const TopoDS_Shape& aShape = aPrs.shape();
+ if (!aShape.IsNull())
+ setSketchPlane(aShape);
}
}
-void PartSet_OperationSketch::mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+
+void PartSet_OperationSketch::mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
if (hasSketchPlane()) {
/// TODO: OCC bug: 25034 - the highlighted list should be filled not only for AIS_Shape
/// but for other IO, for example constraint dimensions.
/// It is empty and we have to use the process mouse release to start edition operation
/// for these objects
- if (theSelected.size() == 1) {
- ObjectPtr aObject = theSelected.front().object();
+ if (aSelected.size() == 1) {
+ ObjectPtr aObject = aSelected.first().object();
if (aObject) {
restartOperation(PartSet_OperationFeatureEdit::Type(), aObject);
}
}
}
-void PartSet_OperationSketch::mouseMoved(QMouseEvent* theEvent, Handle(V3d_View) theView)
+void PartSet_OperationSketch::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
{
if (!hasSketchPlane() || !(theEvent->buttons() & Qt::LeftButton) || myFeatures.empty())
return;
if (myFeatures.size() != 1) {
- FeaturePtr aFeature = PartSet_Tools::nearestFeature(theEvent->pos(), theView, feature(),
+ Handle(V3d_View) aView = theViewer->activeView();
+ FeaturePtr aFeature = PartSet_Tools::nearestFeature(theEvent->pos(), aView, feature(),
myFeatures);
if (aFeature)
restartOperation(PartSet_OperationFeatureEditMulti::Type(), aFeature);
#include <SketchPlugin_Sketch.h>
#include <QObject>
+#include <QList>
class Handle_AIS_InteractiveObject;
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mousePressed(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection);
+
/// Processes the mouse release in the point
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
/// Gives the current mouse point in the viewer
/// \param thePoint a point clicked in the viewer
/// \param theEvent the mouse event
- virtual void mouseMoved(QMouseEvent* theEvent, Handle_V3d_View theView);
+ virtual void mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer);
/// Returns the list of the nested features
/// \return the list of subfeatures
/// Set the plane to the current sketch
/// \param theShape the shape
void setSketchPlane(const TopoDS_Shape& theShape);
+
+ /// Called on selection changed when the operation is active
+ virtual void selectionChanged(ModuleBase_ISelection* theSelection);
/// If operation needs to redisplay its result during operation
/// then this method has to return True
virtual void afterCommitOperation();
private:
- std::list<ModuleBase_ViewerPrs> myFeatures; ///< the features to apply the edit operation
+ QList<ModuleBase_ViewerPrs> myFeatures; ///< the features to apply the edit operation
};
#endif
#include <ModelAPI_ResultBody.h>
#include <ModuleBase_IPropertyPanel.h>
+#include <ModuleBase_IViewer.h>
#include <ModuleBase_ModelWidget.h>
#include <ModuleBase_WidgetValueFeature.h>
return myFeature;
}
-void PartSet_OperationSketchBase::mousePressed(
- QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+void PartSet_OperationSketchBase::mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection)
{
}
void PartSet_OperationSketchBase::mouseReleased(
- QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+ QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection)
{
}
-void PartSet_OperationSketchBase::mouseMoved(QMouseEvent* theEvent, Handle(V3d_View) theView)
+void PartSet_OperationSketchBase::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
{
}
void PartSet_OperationSketchBase::mouseDoubleClick(
QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted)
+ ModuleBase_ISelection* theSelection)
+{
+}
+
+void PartSet_OperationSketchBase::selectionChanged(ModuleBase_ISelection* theSelection)
{
}
}
-
-void PartSet_OperationSketchBase::activateByPreselection()
-{
- if (!myPropertyPanel)
- return;
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- if ((myPreSelection.size() > 0) && aActiveWgt) {
- const ModuleBase_ViewerPrs& aPrs = myPreSelection.front();
- ModuleBase_WidgetValueFeature aValue;
- aValue.setObject(aPrs.object());
- if (aActiveWgt->setValue(&aValue)) {
- myPreSelection.remove(aPrs);
- if(isValid()) {
- //myActiveWidget = NULL;
- commit();
- } else {
- myPropertyPanel->activateNextWidget();
- //emit activateNextWidget(myActiveWidget);
- }
- }
- // If preselection is enough to make a valid feature - apply it immediately
- }
-}
class QMouseEvent;
class GeomAPI_Shape;
class ModuleBase_ViewerPrs;
+class ModuleBase_ISelection;
+class ModuleBase_IViewer;
/*!
\class PartSet_OperationSketchBase
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mousePressed(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection);
/// Processes the mouse release in the point
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
- virtual void mouseReleased(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ virtual void mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
+ ModuleBase_ISelection* theSelection);
/// Processes the mouse move in the point
/// \param theEvent the mouse event
/// \param theView a viewer to have the viewer the eye position
- virtual void mouseMoved(QMouseEvent* theEvent, Handle_V3d_View theView);
+ virtual void mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer);
/// Processes the mouse double click in the point
/// \param theEvent the mouse event
/// \param theSelected the list of selected presentations
/// \param theHighlighted the list of highlighted presentations
virtual void mouseDoubleClick(QMouseEvent* theEvent, Handle_V3d_View theView,
- const std::list<ModuleBase_ViewerPrs>& theSelected,
- const std::list<ModuleBase_ViewerPrs>& theHighlighted);
+ ModuleBase_ISelection* theSelection);
+
+
+ /// Called on selection changed when the operation is active
+ virtual void selectionChanged(ModuleBase_ISelection* theSelection);
/// Emits a signal about the operation start. This signal has an information about the feature.
/// If the provided feature is empty, the current operation feature is used.
/// signal to enable/disable multi selection in the viewer
/// \param theEnabled the boolean state
- void multiSelectionEnabled(bool theEnabled);
+ //void multiSelectionEnabled(bool theEnabled);
/// signal to enable/disable selection in the viewer
/// \param theFeatures a list of features to be disabled
/// \param theFlushMessage the flag whether the create message should be flushed
/// \returns the created feature
virtual FeaturePtr createFeature(const bool theFlushMessage = true);
-
- /// Activates widgets by preselection if it is accepted
- virtual void activateByPreselection();
};
#endif
FeaturePtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView,
FeaturePtr theSketch,
- const std::list<ModuleBase_ViewerPrs>& theFeatures)
+ const QList<ModuleBase_ViewerPrs>& theFeatures)
{
double aX, anY;
gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(thePoint, theView);
PartSet_Tools::convertTo2D(aPoint, theSketch, theView, aX, anY);
FeaturePtr aFeature;
- std::list<ModuleBase_ViewerPrs>::const_iterator anIt = theFeatures.begin(), aLast = theFeatures
- .end();
-
FeaturePtr aDeltaFeature;
double aMinDelta = -1;
ModuleBase_ViewerPrs aPrs;
- for (; anIt != aLast; anIt++) {
- aPrs = *anIt;
+ foreach (ModuleBase_ViewerPrs aPrs, theFeatures) {
if (!aPrs.object())
continue;
boost::shared_ptr<SketchPlugin_Feature> aSketchFeature = boost::dynamic_pointer_cast<
#include <gp_Pnt.hxx>
#include <QPoint>
+#include <QList>
#include <ModelAPI_CompositeFeature.h>
#include <boost/shared_ptr.hpp>
-#include <list>
-
class Handle_V3d_View;
class ModuleBase_ViewerPrs;
class GeomDataAPI_Point2D;
/// \param theSketch the sketch feature
/// \param theFeatures the list of selected presentations
static FeaturePtr nearestFeature(QPoint thePoint, Handle_V3d_View theView, FeaturePtr theSketch,
- const std::list<ModuleBase_ViewerPrs>& theFeatures);
+ const QList<ModuleBase_ViewerPrs>& theFeatures);
/// Returns pointer to the root document.
static boost::shared_ptr<ModelAPI_Document> document();
#include <BRep_Tool.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAbs_CurveType.hxx>
+#include <ModuleBase_ISelection.h>
#include <list>
int shapesNbPoints(const ModuleBase_ISelection* theSelection)
{
- std::list<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
- std::list<ModuleBase_ViewerPrs>::iterator it;
- ModuleBase_ViewerPrs aPrs;
+ QList<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
int aCount = 0;
- for (it = aList.begin(); it != aList.end(); ++it) {
- aPrs = *it;
+ foreach (ModuleBase_ViewerPrs aPrs, aList) {
const TopoDS_Shape& aShape = aPrs.shape();
if (!aShape.IsNull()) {
if (aShape.ShapeType() == TopAbs_VERTEX)
int shapesNbLines(const ModuleBase_ISelection* theSelection)
{
- std::list<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
- std::list<ModuleBase_ViewerPrs>::iterator it;
- ModuleBase_ViewerPrs aPrs;
+ QList<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
int aCount = 0;
- for (it = aList.begin(); it != aList.end(); ++it) {
- aPrs = *it;
+ foreach(ModuleBase_ViewerPrs aPrs, aList) {
const TopoDS_Shape& aShape = aPrs.shape();
if (!aShape.IsNull()) {
if (aShape.ShapeType() == TopAbs_EDGE) {
bool PartSet_RadiusValidator::isValid(const ModuleBase_ISelection* theSelection) const
{
- std::list<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
- std::list<ModuleBase_ViewerPrs>::iterator it;
+ QList<ModuleBase_ViewerPrs> aList = theSelection->getSelected();
ModuleBase_ViewerPrs aPrs;
int aCount = 0;
- for (it = aList.begin(); it != aList.end(); ++it) {
- aPrs = *it;
+ foreach (ModuleBase_ViewerPrs aPrs, aList) {
const TopoDS_Shape& aShape = aPrs.shape();
if (!aShape.IsNull()) {
if (aShape.ShapeType() == TopAbs_EDGE) {
aContext->ClearSelected();
foreach(ObjectPtr aResult, theResults)
{
- if (myResult2AISObjectMap.find(aResult) == myResult2AISObjectMap.end())
- continue;
-
- AISObjectPtr anObj = myResult2AISObjectMap[aResult];
- if (anObj) {
+ if (isVisible(aResult)) {
+ AISObjectPtr anObj = myResult2AISObjectMap[aResult];
Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
if (!anAIS.IsNull())
- aContext->AddOrRemoveSelected(anAIS, false);
+ aContext->SetSelected(anAIS, false);
}
}
if (isUpdateViewer)
{
XGUI_Displayer* aDisp = myWorkshop->displayer();
return aDisp->getObject(theAIS);
+}
+
+void XGUI_ModuleConnector::setSelected(const QList<ObjectPtr>& theFeatures)
+{
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->setSelected(theFeatures);
}
\ No newline at end of file
//! Returns data object by AIS
virtual ObjectPtr findPresentedObject(const AISObjectPtr& theAIS) const;
+ //! Select features clearing previous selection.
+ //! If the list is empty then selection will be cleared
+ virtual void setSelected(const QList<ObjectPtr>& theFeatures);
+
XGUI_Workshop* workshop() const { return myWorkshop; }
private:
/// Returns main widget of the property panel, which children will be created
/// by WidgetFactory using the XML definition
QWidget* contentWidget();
+
/// Brings back all widget created by widget factory for signal/slot
/// connections and further processing
void setModelWidgets(const QList<ModuleBase_ModelWidget*>& theWidgets);
+
/// Returns all property panel's widget created by WidgetFactory
- const QList<ModuleBase_ModelWidget*>& modelWidgets() const;
+ virtual const QList<ModuleBase_ModelWidget*>& modelWidgets() const;
+
/// Removes all widgets in the widget area of the property panel
void cleanContent();
{
}
-std::list<ModuleBase_ViewerPrs> XGUI_Selection::getSelected(int theShapeTypeToSkip) const
+QList<ModuleBase_ViewerPrs> XGUI_Selection::getSelected(int theShapeTypeToSkip) const
{
std::set<ObjectPtr> aPrsFeatures;
- std::list<ModuleBase_ViewerPrs> aPresentations;
+ QList<ModuleBase_ViewerPrs> aPresentations;
XGUI_Displayer* aDisplayer = myWorkshop->displayer();
Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
}
Handle(SelectMgr_EntityOwner) anOwner = aContext->SelectedOwner();
aPrs.setOwner(anOwner);
- aPresentations.push_back(aPrs);
+ aPresentations.append(aPrs);
}
return aPresentations;
}
-std::list<ModuleBase_ViewerPrs> XGUI_Selection::getHighlighted(int theShapeTypeToSkip) const
+QList<ModuleBase_ViewerPrs> XGUI_Selection::getHighlighted(int theShapeTypeToSkip) const
{
std::set<ObjectPtr> aPrsFeatures;
- std::list<ModuleBase_ViewerPrs> aPresentations;
+ QList<ModuleBase_ViewerPrs> aPresentations;
XGUI_Displayer* aDisplayer = myWorkshop->displayer();
Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
#include <NCollection_List.hxx>
#include <TopoDS_Shape.hxx>
-#include <list>
-
class XGUI_Workshop;
class XGUI_EXPORT XGUI_Selection : public ModuleBase_ISelection
/// Returns a list of viewer selected presentations
/// \param theShapeTypeToSkip the shapes with this type will be skipped during the result list build
/// \return list of presentations
- virtual std::list<ModuleBase_ViewerPrs> getSelected(int theShapeTypeToSkip = -1) const;
+ virtual QList<ModuleBase_ViewerPrs> getSelected(int theShapeTypeToSkip = -1) const;
/// Returns a list of viewer highlited presentations
/// \param theShapeTypeToSkip the shapes with this type will be skipped during the result list build
/// \return list of presentations
- virtual std::list<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const;
+ virtual QList<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const;
/**
* Returns list of currently selected objects
myEventStarted(false),
myIsActive(false),
myLastState(WindowNormalState),
- myOperation(NOTHING)
+ myOperation(NOTHING),
+ myGripWgt(0),
+ myPicture(0)
{
mySelectedPoint = gp_Pnt(0., 0., 0.);
setFrameStyle(QFrame::Raised);
ModuleBase_Tools::zeroMargins(myPropertyPanel->contentWidget());
QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
- QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
- ModuleBase_ModelWidget* aWidget;
- for (; anIt != aLast; anIt++) {
- aWidget = *anIt;
+ foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
aWidget->setFeature(aOperation->feature());
aWidget->enableFocusProcessing();
QObject::connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
aOperation->setPropertyPanel(myPropertyPanel);
myPropertyPanel->setModelWidgets(aWidgets);
- myPropertyPanel->activateNextWidget(NULL);
+ if (!aOperation->activateByPreselection())
+ myPropertyPanel->activateNextWidget(NULL);
// Widget activation (from the previous method) may commit the current operation
// if pre-selection is enougth for it. So we shouldn't update prop panel's title
if(myOperationMgr->isCurrentOperation(aOperation)) {
