##
#------ NewGEOM ------
-export NEW_GEOM_ROOT_DIR=${ROOT_DIR}/install
-export PATH=${NEW_GEOM_ROOT_DIR}/bin:${NEW_GEOM_ROOT_DIR}/plugins:${PATH}
-export PYTHONPATH=${NEW_GEOM_ROOT_DIR}/swig:${PYTHONPATH}
-export LD_LIBRARY_PATH=${NEW_GEOM_ROOT_DIR}/bin:${NEW_GEOM_ROOT_DIR}/swig:${NEW_GEOM_ROOT_DIR}/plugins:${LD_LIBRARY_PATH}
-export NEW_GEOM_CONFIG_FILE=${NEW_GEOM_ROOT_DIR}/plugins
-export NewGeomResources=${NEW_GEOM_ROOT_DIR}/resources
+export NEWGEOM_ROOT_DIR=${ROOT_DIR}/install
+export PATH=${NEWGEOM_ROOT_DIR}/bin:${NEWGEOM_ROOT_DIR}/plugins:${PATH}
+export PYTHONPATH=${NEWGEOM_ROOT_DIR}/swig:${PYTHONPATH}
+export LD_LIBRARY_PATH=${NEWGEOM_ROOT_DIR}/bin:${NEWGEOM_ROOT_DIR}/swig:${NEWGEOM_ROOT_DIR}/plugins:${LD_LIBRARY_PATH}
+export NEW_GEOM_CONFIG_FILE=${NEWGEOM_ROOT_DIR}/plugins
+export NewGeomResources=${NEWGEOM_ROOT_DIR}/resources
# Correcting path which defined with error
export LD_LIBRARY_PATH=${KERNEL_ROOT_DIR}/lib/salome:${LD_LIBRARY_PATH}
-export LightAppConfig=${ROOT_DIR}/install/share/salome/resources/newgeom:${GUI_ROOT_DIR}/share/salome/resources/gui
+export SalomeAppConfig=${ROOT_DIR}/install/share/salome/resources/newgeom:${GUI_ROOT_DIR}/share/salome/resources/gui
-SUITApp LightApp --modules=NewGeom
\ No newline at end of file
+${PYTHONBIN} "${KERNEL_ROOT_DIR}/bin/salome/envSalome.py"
+${PYTHONBIN} "${KERNEL_ROOT_DIR}/bin/salome/runSalome.py"
aSession.startOperation()
aFeature = aDoc.addFeature("Point")
aFeatureData = aFeature.data()
+assert(aFeatureData is not None)
aFeatureData.real("x").setValue(0.)
aFeatureData.real("y").setValue(0.)
aFeatureData.real("z").setValue(0.)
-aFeatureName = aFeatureData.name()
+aFeatureName = aFeature.name()
aFeature.execute()
aSession.finishOperation()
EXCHANGEPLUGIN_EXPORT virtual bool isInHistory()
{
- return false;
+ return true;
}
protected:
#include <ModelAPI_Feature.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <GeomData_Point.h>
#include <GeomData_Point2D.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_CompositeFeature.h>
+#include <ModelAPI_Session.h>
#include <Events_Loop.h>
#include <Events_LongOp.h>
#include <Events_Error.h>
#include "ModelAPI_Session.h"
#include "ModelAPI_Object.h"
#include "ModelAPI_Feature.h"
+ #include "ModelAPI_CompositeFeature.h"
#include "ModelAPI_Data.h"
#include "ModelAPI_Attribute.h"
#include "ModelAPI_AttributeDocRef.h"
#include "ModelAPI_ResultBody.h"
#include "ModelAPI_ResultPart.h"
- template<class T> boost::shared_ptr<T> castTo(boost::shared_ptr<ModelAPI_Result> theObject)
+ template<class T1, class T2>
+ boost::shared_ptr<T1> boost_cast(boost::shared_ptr<T2> theObject)
{
- return boost::dynamic_pointer_cast<T>(theObject);
+ return boost::dynamic_pointer_cast<T1>(theObject);
}
-
%}
// to avoid error on this
%shared_ptr(ModelAPI_Session)
%shared_ptr(ModelAPI_Object)
%shared_ptr(ModelAPI_Feature)
+%shared_ptr(ModelAPI_CompositeFeature)
%shared_ptr(ModelAPI_Data)
%shared_ptr(ModelAPI_Attribute)
%shared_ptr(ModelAPI_AttributeDocRef)
%include "ModelAPI_Session.h"
%include "ModelAPI_Object.h"
%include "ModelAPI_Feature.h"
+%include "ModelAPI_CompositeFeature.h"
%include "ModelAPI_Data.h"
%include "ModelAPI_Attribute.h"
%include "ModelAPI_AttributeDocRef.h"
%template(ObjectList) std::list<boost::shared_ptr<ModelAPI_Object> >;
%template(ResultList) std::list<boost::shared_ptr<ModelAPI_Result> >;
-template<class T> boost::shared_ptr<T> castTo(boost::shared_ptr<ModelAPI_Result> theObject);
-%template(modelAPI_ResultConstruction) castTo<ModelAPI_ResultConstruction>;
-%template(modelAPI_ResultBody) castTo<ModelAPI_ResultBody>;
-%template(modelAPI_ResultPart) castTo<ModelAPI_ResultPart>;
+template<class T1, class T2> boost::shared_ptr<T1> boost_cast(boost::shared_ptr<T2> theObject);
+%template(modelAPI_CompositeFeature) boost_cast<ModelAPI_CompositeFeature, ModelAPI_Feature>;
+%template(modelAPI_ResultConstruction) boost_cast<ModelAPI_ResultConstruction, ModelAPI_Result>;
+%template(modelAPI_ResultBody) boost_cast<ModelAPI_ResultBody, ModelAPI_Result>;
+%template(modelAPI_ResultPart) boost_cast<ModelAPI_ResultPart, ModelAPI_Result>;
+
+
}
};
+typedef boost::shared_ptr<ModelAPI_AttributeBoolean> AttributeBooleanPtr;
+
#endif
}
};
+typedef boost::shared_ptr<ModelAPI_AttributeDocRef> AttributeDocRefPtr;
+
#endif
}
};
+typedef boost::shared_ptr<ModelAPI_AttributeRefAttr> AttributeRefAttrPtr;
+
#endif
}
};
+typedef boost::shared_ptr<ModelAPI_AttributeRefList> AttributeRefListPtr;
+
#endif
}
};
+typedef boost::shared_ptr<ModelAPI_AttributeReference> AttributeReferencePtr;
+
#endif
/// Returns the sub-feature unique identifier in this composite feature by zero-base index
virtual int subFeatureId(const int theIndex) const = 0;
+
+ /// Returns true if feature or reuslt belong to this composite feature as subs
+ virtual bool isSub(ObjectPtr theObject) const = 0;
};
//! Pointer on the composite feature object
#include <ModelAPI_Result.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
+#include <ModelAPI_Session.h>
#include <Events_Loop.h>
const std::list<boost::shared_ptr<ModelAPI_Result> >& ModelAPI_Feature::results()
#ifndef ModelAPI_Feature_H_
#define ModelAPI_Feature_H_
-#include "ModelAPI_Object.h"
-#include "ModelAPI_Session.h"
+#include <ModelAPI.h>
+#include <ModelAPI_Object.h>
+#include <ModelAPI_AttributeBoolean.h>
+#include <ModelAPI_AttributeDocRef.h>
+#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_AttributeInteger.h>
+#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_AttributeReference.h>
+#include <ModelAPI_AttributeSelection.h>
+#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_AttributeString.h>
+#include <ModelAPI_AttributeRefList.h>
+#include <ModelAPI_Data.h>
+#include <ModelAPI_Document.h>
+#include <ModelAPI_Result.h>
-#include <string>
-#include <list>
#include <boost/shared_ptr.hpp>
+#include <list>
+#include <string>
+
class ModelAPI_Data;
class ModelAPI_Document;
class ModelAPI_Result;
return MY_GROUP;
}
+ /// Returns document this feature belongs to
+ virtual boost::shared_ptr<ModelAPI_Document> document() const
+ {
+ return ModelAPI_Object::document();
+ }
+
/// Returns the group identifier of this result
virtual std::string groupName()
{
MODELAPI_EXPORT static boost::shared_ptr<ModelAPI_Feature> feature(ObjectPtr theObject);
+ //
+ // Helper methods, aliases for data()->method()
+ // -----------------------------------------------------------------------------------------------
+ inline std::string name()
+ {
+ return data()->name();
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeBoolean> boolean(const std::string& theID)
+ {
+ return data()->boolean(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeDocRef> document(const std::string& theID)
+ {
+ return data()->document(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeDouble> real(const std::string& theID)
+ {
+ return data()->real(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeInteger> integer(const std::string& theID)
+ {
+ return data()->integer(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeRefAttr> refattr(const std::string& theID)
+ {
+ return data()->refattr(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeReference> reference(const std::string& theID)
+ {
+ return data()->reference(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeRefList> reflist(const std::string& theID)
+ {
+ return data()->reflist(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeSelection> selection(const std::string& theID)
+ {
+ return data()->selection(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeSelectionList> selectionList(const std::string& theID)
+ {
+ return data()->selectionList(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_AttributeString> string(const std::string& theID)
+ {
+ return data()->string(theID);
+ }
+
+ inline boost::shared_ptr<ModelAPI_Attribute> attribute(const std::string& theID)
+ {
+ return data()->attribute(theID);
+ }
+ // -----------------------------------------------------------------------------------------------
};
//! Pointer on feature object
typedef boost::shared_ptr<ModelAPI_Feature> FeaturePtr;
#endif
+
}
/// Returns document this feature belongs to
- virtual boost::shared_ptr<ModelAPI_Document> document()
+ virtual boost::shared_ptr<ModelAPI_Document> document() const
{
return myDoc;
}
\r
aSession.startOperation()\r
aFeature = aDoc.addFeature("Point")\r
-aFeatureData = aFeature.data()\r
# Since validators are introduced we have to initialize all\r
# the feature's attributes\r
-aFeatureData.real("x").setValue(1.)\r
-aFeatureData.real("y").setValue(-1.)\r
-aFeatureData.real("z").setValue(0.)\r
-aFeatureName = aFeatureData.name()\r
+aFeature.real("x").setValue(1.)\r
+aFeature.real("y").setValue(-1.)\r
+aFeature.real("z").setValue(0.)\r
+aFeatureName = aFeature.name()\r
assert(aFeatureName == "Point_1")\r
\r
aFeature.execute()\r
#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>
#include <ModelAPI_Document.h>
#include <ModelAPI_Events.h>
#include <ModelAPI_Result.h>
+#include <ModelAPI_Object.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <GeomAPI_Pnt2d.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.clear();
+
+ // Check that the selected result are not results of operation feature
+ QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+ FeaturePtr aFeature = feature();
+ if (aFeature) {
+ std::list<ResultPtr> aResults = aFeature->results();
+ QList<ObjectPtr> aResList;
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt)
+ aResList.append(*aIt);
+
+ foreach (ModuleBase_ViewerPrs aPrs, aSelected) {
+ if ((!aResList.contains(aPrs.object())) && (aPrs.object() != aFeature))
+ myPreSelection.append(aPrs);
+ }
+ } else
+ myPreSelection = aSelected;
}
void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
{
- activateByPreselection();
+ //activateByPreselection();
//if (theWidget && myPropertyPanel) {
// myPropertyPanel->activateNextWidget();
//// //emit activateNextWidget(myActiveWidget);
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);
return aD1 && aD2 && aD3;
}
}
+ } else {
+ // This is not object controlled by the filter
+ return Standard_True;
}
}
return Standard_False;
#include <QLayout>
#include <QLabel>
#include <QEvent>
-#include <QKeyEvent>
#include <QTimer>
#include <math.h>
#include <ModuleBase_WidgetMultiSelector.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <Config_Keywords.h>
#include <Config_WidgetAPI.h>
ModuleBase_WidgetFactory::~ModuleBase_WidgetFactory()
{
+ delete myWidgetApi;
}
void ModuleBase_WidgetFactory::createWidget(QWidget* theParent)
#include <ModelAPI_Validator.h>
#include <ModelAPI_ResultValidator.h>
#include <ModelAPI_RefAttrValidator.h>
+#include <ModelAPI_Session.h>
#include <QWidget>
#include <QLineEdit>
#include <ModelAPI_Data.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <ModuleBase_WidgetFileSelector.h>
#include <ModuleBase_Tools.h>
#include <QGridLayout>
#include <QLabel>
#include <QEvent>
-#include <QKeyEvent>
#include <cfloat>
#include <climits>
#include <XGUI_Workshop.h>
+#include <ModelAPI_Session.h>
+
#include <LightApp_Study.h>
#include <CAM_Application.h>
#include <SUIT_Tools.h>
#include <ModelAPI_Events.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_Data.h>
+#include <ModelAPI_Session.h>
#include <GeomDataAPI_Point2D.h>
#include <GeomDataAPI_Point.h>
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
// Clear standard selection modes
aDisplayer->setSelectionModes(aModes);
aDisplayer->openLocalContext();
- // Get default selection modes
- aModes = sketchSelectionModes(ObjectPtr());
- aDisplayer->activateObjectsOutOfContext(aModes);
// Set filter
mySketchFilter = new ModuleBase_ShapeInPlaneFilter(thePln);
aDisplayer->addSelectionFilter(mySketchFilter);
+
+ // Get default selection modes
+ aModes = sketchSelectionModes(ObjectPtr());
+ aDisplayer->activateObjectsOutOfContext(aModes);
}
void PartSet_Module::onFeatureConstructed(ObjectPtr theFeature, int theMode)
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();
+ // We have to select a plane before any operation
+ 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
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeRefList.h>
#include <ModelAPI_Document.h>
+#include <ModelAPI_Session.h>
#include <GeomDataAPI_Point.h>
#include <GeomDataAPI_Dir.h>
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) {
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Session.h>
using namespace std;
#include <ModelAPI_Data.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Session.h>
void PartSetPlugin_Remove::execute()
{
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <GeomAPI_Circ2d.h>
#include <GeomAPI_Pnt2d.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_Session.h>
#include <GeomAPI_Pnt2d.h>
#include <GeomDataAPI_Point2D.h>
#include <GeomAlgoAPI_PointBuilder.h>
#include <GeomAlgoAPI_EdgeBuilder.h>
#include <GeomAlgoAPI_CompoundBuilder.h>
-#include <ModelAPI_AttributeDouble.h>
SketchPlugin_Circle::SketchPlugin_Circle()
: SketchPlugin_Feature()
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Lin2d.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
#include <GeomAPI_Pnt2d.h>
return subFeature(theIndex)->data()->featureId();
}
+bool SketchPlugin_Sketch::isSub(ObjectPtr theObject) const
+{
+ // check is this feature of result
+ FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
+ if (!aFeature) {
+ ResultPtr aRes = boost::dynamic_pointer_cast<ModelAPI_Result>(theObject);
+ if (aRes)
+ aFeature = document()->feature(aRes);
+ }
+ if (aFeature) {
+ list<ObjectPtr> aSubs = data()->reflist(SketchPlugin_Sketch::FEATURES_ID())->list();
+ for(list<ObjectPtr>::iterator aSubIt = aSubs.begin(); aSubIt != aSubs.end(); aSubIt++) {
+ if (*aSubIt == aFeature)
+ return true;
+ }
+ }
+ return false;
+}
+
boost::shared_ptr<GeomAPI_Pnt> SketchPlugin_Sketch::to3D(const double theX, const double theY)
{
boost::shared_ptr<GeomDataAPI_Point> aC = boost::dynamic_pointer_cast<GeomDataAPI_Point>(
/// Returns the sub-feature unique identifier in this composite feature by zero-base index
SKETCHPLUGIN_EXPORT virtual int subFeatureId(const int theIndex) const;
+ /// Returns true if feature or reuslt belong to this composite feature as subs
+ SKETCHPLUGIN_EXPORT virtual bool isSub(ObjectPtr theObject) const;
+
/// Construction result is allways recomuted on the fly
SKETCHPLUGIN_EXPORT virtual bool isPersistentResult() {return false;}
#include <ModelAPI_ResultValidator.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_Session.h>
#include <GeomDataAPI_Point2D.h>
bool SketchPlugin_DistanceAttrValidator::isValid(const FeaturePtr& theFeature,
# Initialization of the test
#=========================================================================
-__updated__ = "2014-07-28"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
#=========================================================================
aSession.startOperation()
aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Create a line and an arc
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
aSketchArc = aDocument.addFeature("SketchArc")
aSketchReflist.append(aSketchArc)
-aSketchArcData = aSketchArc.data()
-anArcCentr = geomDataAPI_Point2D(aSketchArcData.attribute("ArcCenter"))
+anArcCentr = geomDataAPI_Point2D(aSketchArc.attribute("ArcCenter"))
anArcStartPoint = geomDataAPI_Point2D(
- aSketchArcData.attribute("ArcStartPoint"))
-anArcEndPoint = geomDataAPI_Point2D(aSketchArcData.attribute("ArcEndPoint"))
+ aSketchArc.attribute("ArcStartPoint"))
+anArcEndPoint = geomDataAPI_Point2D(aSketchArc.attribute("ArcEndPoint"))
aSketchFeature = aDocument.addFeature("SketchConstraintCoincidence")
anArcCentr.setValue(10., 10.)
anArcStartPoint.setValue(0., 50.)
anArcEndPoint.setValue(50., 0.)
aSketchLine = aDocument.addFeature("SketchLine")
aSketchReflist.append(aSketchLine)
-aSketchLineData = aSketchLine.data()
-aLineStartPoint = geomDataAPI_Point2D(aSketchLineData.attribute("StartPoint"))
-aLineEndPoint = geomDataAPI_Point2D(aSketchLineData.attribute("EndPoint"))
+aLineStartPoint = geomDataAPI_Point2D(aSketchLine.attribute("StartPoint"))
+aLineEndPoint = geomDataAPI_Point2D(aSketchLine.attribute("EndPoint"))
# Lets initialize line start at circle's end:
aLineStartPoint.setValue(50., 0.)
aLineEndPoint.setValue(100., 25.)
aSession.startOperation()
aConstraint = aDocument.addFeature("SketchConstraintCoincidence")
aSketchReflist.append(aConstraint)
-aConstraintData = aConstraint.data()
-reflistA = aConstraintData.refattr("ConstraintEntityA")
-reflistB = aConstraintData.refattr("ConstraintEntityB")
+reflistA = aConstraint.refattr("ConstraintEntityA")
+reflistB = aConstraint.refattr("ConstraintEntityB")
reflistA.setAttr(anArcEndPoint)
reflistB.setAttr(aLineStartPoint)
aSession.finishOperation()
# Initialization of the test
#=========================================================================
-__updated__ = "2014-07-29"
+__updated__ = "2014-10-28"
def distance(pointA, pointB):
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Create a point and a line
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
-aSketchPoint = aDocument.addFeature("SketchPoint")
-aSketchReflist.append(aSketchPoint)
-aSketchPointData = aSketchPoint.data()
+aSketchPoint = aSketchFeature.addFeature("SketchPoint")
aSketchPointCoords = geomDataAPI_Point2D(
- aSketchPointData.attribute("PointCoordindates"))
+ aSketchPoint.attribute("PointCoordindates"))
aSketchPointCoords.setValue(50., 50.)
-aSketchLine = aDocument.addFeature("SketchLine")
-aSketchReflist.append(aSketchLine)
-aLineAStartPoint = geomDataAPI_Point2D(
- aSketchLine.data().attribute("StartPoint"))
-aLineAEndPoint = geomDataAPI_Point2D(aSketchLine.data().attribute("EndPoint"))
+aSketchLine = aSketchFeature.addFeature("SketchLine")
+aLineAStartPoint = geomDataAPI_Point2D(aSketchLine.attribute("StartPoint"))
+aLineAEndPoint = geomDataAPI_Point2D(aSketchLine.attribute("EndPoint"))
aLineAStartPoint.setValue(0., 25.)
aLineAEndPoint.setValue(100., 25.)
aSession.finishOperation()
#=========================================================================
assert (distance(aSketchPointCoords, aLineAStartPoint) != 25.)
aSession.startOperation()
-aConstraint = aDocument.addFeature("SketchConstraintDistance")
-aSketchReflist.append(aConstraint)
-aConstraintData = aConstraint.data()
-aDistance = aConstraintData.real("ConstraintValue")
-refattrA = aConstraintData.refattr("ConstraintEntityA")
-refattrB = aConstraintData.refattr("ConstraintEntityB")
+aConstraint = aSketchFeature.addFeature("SketchConstraintDistance")
+aDistance = aConstraint.real("ConstraintValue")
+refattrA = aConstraint.refattr("ConstraintEntityA")
+refattrB = aConstraint.refattr("ConstraintEntityB")
assert (not aDistance.isInitialized())
assert (not refattrA.isInitialized())
assert (not refattrB.isInitialized())
# Initialization of the test
#=========================================================================
-__updated__ = "2014-09-26"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Create a line with length 100
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
-aSketchLineA = aDocument.addFeature("SketchLine")
-aSketchReflist.append(aSketchLineA)
-aLineAStartPoint = geomDataAPI_Point2D(
- aSketchLineA.data().attribute("StartPoint"))
-aLineAEndPoint = geomDataAPI_Point2D(aSketchLineA.data().attribute("EndPoint"))
+aSketchLineA = aSketchFeature.addFeature("SketchLine")
+aLineAStartPoint = geomDataAPI_Point2D(aSketchLineA.attribute("StartPoint"))
+aLineAEndPoint = geomDataAPI_Point2D(aSketchLineA.attribute("EndPoint"))
aLineAStartPoint.setValue(0., 25.)
aLineAEndPoint.setValue(100., 25.)
aSession.finishOperation()
# Make a constraint to keep the length
#=========================================================================
aSession.startOperation()
-aLengthConstraint = aDocument.addFeature("SketchConstraintLength")
-aSketchReflist.append(aLengthConstraint)
-aConstraintData = aLengthConstraint.data()
-refattrA = aConstraintData.refattr("ConstraintEntityA")
-aLength = aConstraintData.real("ConstraintValue")
+aLengthConstraint = aSketchFeature.addFeature("SketchConstraintLength")
+refattrA = aLengthConstraint.refattr("ConstraintEntityA")
+aLength = aLengthConstraint.real("ConstraintValue")
assert (not refattrA.isInitialized())
assert (not aLength.isInitialized())
# Initialization of the test
#=========================================================================
-__updated__ = "2014-09-26"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Create two lines which are not parallel
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
# line A
-aSketchLineA = aDocument.addFeature("SketchLine")
-aSketchReflist.append(aSketchLineA)
-aLineAStartPoint = geomDataAPI_Point2D(
- aSketchLineA.data().attribute("StartPoint"))
-aLineAEndPoint = geomDataAPI_Point2D(
- aSketchLineA.data().attribute("EndPoint"))
-aSketchLineB = aDocument.addFeature("SketchLine")
+aSketchLineA = aSketchFeature.addFeature("SketchLine")
+aLineAStartPoint = geomDataAPI_Point2D(aSketchLineA.attribute("StartPoint"))
+aLineAEndPoint = geomDataAPI_Point2D(aSketchLineA.attribute("EndPoint"))
+aSketchLineB = aSketchFeature.addFeature("SketchLine")
aLineAStartPoint.setValue(0., 25)
aLineAEndPoint.setValue(85., 25)
# line B
-aSketchReflist.append(aSketchLineB)
-aLineBStartPoint = geomDataAPI_Point2D(
- aSketchLineB.data().attribute("StartPoint"))
-aLineBEndPoint = geomDataAPI_Point2D(
- aSketchLineB.data().attribute("EndPoint"))
+aLineBStartPoint = geomDataAPI_Point2D(aSketchLineB.attribute("StartPoint"))
+aLineBEndPoint = geomDataAPI_Point2D(aSketchLineB.attribute("EndPoint"))
aLineBStartPoint.setValue(0., 50)
aLineBEndPoint.setValue(80., 75)
aSession.finishOperation()
#=========================================================================
for eachFeature in [aSketchLineA, aSketchLineB]:
aSession.startOperation()
- aLengthConstraint = aDocument.addFeature("SketchConstraintLength")
- aSketchReflist.append(aLengthConstraint)
- aLengthConstraintData = aLengthConstraint.data()
- refattrA = aLengthConstraintData.refattr("ConstraintEntityA")
+ aLengthConstraint = aSketchFeature.addFeature("SketchConstraintLength")
+ refattrA = aLengthConstraint.refattr("ConstraintEntityA")
aResultA = modelAPI_ResultConstruction(eachFeature.firstResult())
assert (aResultA is not None)
refattrA.setObject(aResultA)
# Link lines with parallel constraint
#=========================================================================
aSession.startOperation()
-aParallelConstraint = aDocument.addFeature("SketchConstraintParallel")
-aSketchReflist.append(aParallelConstraint)
-aConstraintData = aParallelConstraint.data()
-refattrA = aConstraintData.refattr("ConstraintEntityA")
-refattrB = aConstraintData.refattr("ConstraintEntityB")
+aParallelConstraint = aSketchFeature.addFeature("SketchConstraintParallel")
+refattrA = aParallelConstraint.refattr("ConstraintEntityA")
+refattrB = aParallelConstraint.refattr("ConstraintEntityB")
# aResultA is already defined for the length constraint
aResultA = modelAPI_ResultConstruction(eachFeature.firstResult())
aResultB = modelAPI_ResultConstruction(aSketchLineB.firstResult())
# Initialization of the test
#=========================================================================
-__updated__ = "2014-09-26"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Create two lines which are already perpendicular
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
# line A
-aSketchLineA = aDocument.addFeature("SketchLine")
-aSketchReflist.append(aSketchLineA)
-aLineAStartPoint = geomDataAPI_Point2D(
- aSketchLineA.data().attribute("StartPoint"))
-aLineAEndPoint = geomDataAPI_Point2D(
- aSketchLineA.data().attribute("EndPoint"))
-aSketchLineB = aDocument.addFeature("SketchLine")
+aSketchLineA = aSketchFeature.addFeature("SketchLine")
+aLineAStartPoint = geomDataAPI_Point2D(aSketchLineA.attribute("StartPoint"))
+aLineAEndPoint = geomDataAPI_Point2D(aSketchLineA.attribute("EndPoint"))
+# line B
+aSketchLineB = aSketchFeature.addFeature("SketchLine")
aLineAStartPoint.setValue(0., 25)
aLineAEndPoint.setValue(85., 25)
-# line B
-aSketchReflist.append(aSketchLineB)
-aLineBStartPoint = geomDataAPI_Point2D(
- aSketchLineB.data().attribute("StartPoint"))
-aLineBEndPoint = geomDataAPI_Point2D(
- aSketchLineB.data().attribute("EndPoint"))
+aLineBStartPoint = geomDataAPI_Point2D(aSketchLineB.attribute("StartPoint"))
+aLineBEndPoint = geomDataAPI_Point2D(aSketchLineB.attribute("EndPoint"))
aLineBStartPoint.setValue(25., 40.)
aLineBEndPoint.setValue(25., 125.)
aSession.finishOperation()
for eachFeature in [aSketchLineA, aSketchLineB]:
aSession.startOperation()
- aLengthConstraint = aDocument.addFeature("SketchConstraintLength")
- aSketchReflist.append(aLengthConstraint)
- aLengthConstraintData = aLengthConstraint.data()
- refattrA = aLengthConstraintData.refattr("ConstraintEntityA")
+ aLengthConstraint = aSketchFeature.addFeature("SketchConstraintLength")
+ refattrA = aLengthConstraint.refattr("ConstraintEntityA")
aResultA = modelAPI_ResultConstruction(eachFeature.firstResult())
assert (aResultA is not None)
refattrA.setObject(aResultA)
# Link lines with perpendicular constraint
#=========================================================================
aSession.startOperation()
-aPerpendicularConstraint = aDocument.addFeature(
+aPerpendicularConstraint = aSketchFeature.addFeature(
"SketchConstraintPerpendicular")
-aSketchReflist.append(aPerpendicularConstraint)
-aConstraintData = aPerpendicularConstraint.data()
-refattrA = aConstraintData.refattr("ConstraintEntityA")
-refattrB = aConstraintData.refattr("ConstraintEntityB")
+refattrA = aPerpendicularConstraint.refattr("ConstraintEntityA")
+refattrB = aPerpendicularConstraint.refattr("ConstraintEntityB")
# aResultA is already defined for the length constraint
aResultB = modelAPI_ResultConstruction(aSketchLineB.firstResult())
assert (aResultB is not None)
# Initialization of the test
#=========================================================================
-__updated__ = "2014-09-26"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Creation of an arc and a circle
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
-aSketchArc = aDocument.addFeature("SketchArc")
-aSketchReflist.append(aSketchArc)
-aSketchArcData = aSketchArc.data()
-anArcCentr = geomDataAPI_Point2D(aSketchArcData.attribute("ArcCenter"))
+aSketchArc = aSketchFeature.addFeature("SketchArc")
+anArcCentr = geomDataAPI_Point2D(aSketchArc.attribute("ArcCenter"))
anArcCentr.setValue(10., 10.)
-anArcStartPoint = geomDataAPI_Point2D(
- aSketchArcData.attribute("ArcStartPoint"))
+anArcStartPoint = geomDataAPI_Point2D(aSketchArc.attribute("ArcStartPoint"))
anArcStartPoint.setValue(0., 50.)
-anArcEndPoint = geomDataAPI_Point2D(aSketchArcData.attribute("ArcEndPoint"))
+anArcEndPoint = geomDataAPI_Point2D(aSketchArc.attribute("ArcEndPoint"))
anArcEndPoint.setValue(50., 0.)
aSession.finishOperation()
# Circle
aSession.startOperation()
-aSketchCircle = aDocument.addFeature("SketchCircle")
-aSketchReflist.append(aSketchCircle)
-aSketchCircleData = aSketchCircle.data()
-anCircleCentr = geomDataAPI_Point2D(
- aSketchCircleData.attribute("CircleCenter"))
-aCircleRadius = aSketchCircleData.real("CircleRadius")
+aSketchCircle = aSketchFeature.addFeature("SketchCircle")
+anCircleCentr = geomDataAPI_Point2D(aSketchCircle.attribute("CircleCenter"))
+aCircleRadius = aSketchCircle.real("CircleRadius")
anCircleCentr.setValue(-25., -25)
aCircleRadius.setValue(25.)
aSession.finishOperation()
# Make a constraint to keep the radius of the arc
#=========================================================================
aSession.startOperation()
-aConstraint = aDocument.addFeature("SketchConstraintRadius")
-aSketchReflist.append(aConstraint)
-aConstraintData = aConstraint.data()
-aRadius = aConstraintData.real("ConstraintValue")
-aRefObject = aConstraintData.refattr("ConstraintEntityA")
+aConstraint = aSketchFeature.addFeature("SketchConstraintRadius")
+aRadius = aConstraint.real("ConstraintValue")
+aRefObject = aConstraint.refattr("ConstraintEntityA")
aResult = aSketchArc.firstResult()
assert (aResult is not None)
aRefObject.setObject(modelAPI_ResultConstruction(aResult))
# Make a constraint to keep the radius of the circle
#=========================================================================
aSession.startOperation()
-aConstraint = aDocument.addFeature("SketchConstraintRadius")
-aSketchReflist.append(aConstraint)
-aConstraintData = aConstraint.data()
-aRadius = aConstraintData.real("ConstraintValue")
-aRefObject = aConstraintData.refattr("ConstraintEntityA")
+aConstraint = aSketchFeature.addFeature("SketchConstraintRadius")
+aRadius = aConstraint.real("ConstraintValue")
+aRefObject = aConstraint.refattr("ConstraintEntityA")
aResult = aSketchCircle.firstResult()
assert (aResult is not None)
aRefObject.setObject(modelAPI_ResultConstruction(aResult))
from GeomDataAPI import *
from ModelAPI import *
-__updated__ = "2014-07-25"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+#aSketchFeature = aDocument.addFeature("Sketch")
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
#=========================================================================
# Creation of an arc
# 1. Test SketchPlugin_Arc attributes
-# 2.
+# 2.
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
assert (not aSketchReflist.isInitialized())
assert (aSketchReflist.size() == 0)
assert (len(aSketchReflist.list()) == 0)
-aSketchArc = aDocument.addFeature("SketchArc")
+aSketchArc = aSketchFeature.addFeature("SketchArc")
assert (aSketchArc.getKind() == "SketchArc")
-aSketchReflist.append(aSketchArc)
-aSketchArcData = aSketchArc.data()
-anArcCentr = geomDataAPI_Point2D(aSketchArcData.attribute("ArcCenter"))
+anArcCentr = geomDataAPI_Point2D(aSketchArc.attribute("ArcCenter"))
assert (anArcCentr.x() == 0)
assert (anArcCentr.y() == 0)
assert (not anArcCentr.isInitialized())
-anArcCentr.setValue(10.,10.)
-anArcStartPoint = geomDataAPI_Point2D(aSketchArcData.attribute("ArcStartPoint"))
+anArcCentr.setValue(10., 10.)
+anArcStartPoint = geomDataAPI_Point2D(
+ aSketchArc.attribute("ArcStartPoint"))
assert (anArcStartPoint.x() == 0)
assert (anArcStartPoint.y() == 0)
assert (not anArcStartPoint.isInitialized())
anArcStartPoint.setValue(0., 50.)
-anArcEndPoint = geomDataAPI_Point2D(aSketchArcData.attribute("ArcEndPoint"))
+anArcEndPoint = geomDataAPI_Point2D(aSketchArc.attribute("ArcEndPoint"))
assert (anArcEndPoint.x() == 0)
assert (anArcEndPoint.y() == 0)
assert (not anArcEndPoint.isInitialized())
anArcEndPoint.setValue(50., 0.)
aSession.finishOperation()
# check that values have been changed
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
assert (aSketchReflist.size() == 1)
assert (len(aSketchReflist.list()) == 1)
assert (anArcCentr.x() == 10.0)
assert (anArcStartPoint.y() == 50.0)
assert (anArcEndPoint.x() == 50.0)
assert (anArcEndPoint.y() == 0.0)
-#===============================================================================
+#=========================================================================
# Edit the arc:
# 1. Move whole arc
-# 2. Change the start point
-#===============================================================================
+# 2. Change the start point
+#=========================================================================
aSession.startOperation()
deltaX, deltaY = 5., 10.
anArcCentr.setValue(anArcCentr.x() + deltaX, anArcCentr.y() + deltaY)
-anArcStartPoint.setValue(anArcStartPoint.x() + deltaX, anArcStartPoint.y() + deltaY)
+anArcStartPoint.setValue(
+ anArcStartPoint.x() + deltaX, anArcStartPoint.y() + deltaY)
anArcEndPoint.setValue(anArcEndPoint.x() + deltaX, anArcEndPoint.y() + deltaY)
aSession.finishOperation()
assert (anArcCentr.x() == 15)
assert (anArcEndPoint.x() != aPrevEndPointX)
assert (anArcEndPoint.y() != aPrevEndPointY)
#=========================================================================
-# Check results of the Arc
+# Check results of the Arc
#=========================================================================
aResult = aSketchArc.firstResult()
aResultConstruction = modelAPI_ResultConstruction(aResult)
aShape = aResultConstruction.shape()
assert (aShape is not None)
assert (not aShape.isNull())
-#===============================================================================
+#=========================================================================
# Create a circle
# 1. Test SketchPlugin_Circle.h attributes
# 2. ModelAPI_AttributeDouble attribute
-#===============================================================================
+#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
# Arc is already added
assert (aSketchReflist.size() == 1)
assert (len(aSketchReflist.list()) == 1)
-aSketchCircle = aDocument.addFeature("SketchCircle")
+aSketchCircle = aSketchFeature.addFeature("SketchCircle")
assert (aSketchCircle.getKind() == "SketchCircle")
-aSketchReflist.append(aSketchCircle)
-aSketchCircleData = aSketchCircle.data()
-anCircleCentr = geomDataAPI_Point2D(aSketchCircleData.attribute("CircleCenter"))
+anCircleCentr = geomDataAPI_Point2D(aSketchCircle.attribute("CircleCenter"))
assert (anCircleCentr.x() == 0)
assert (anCircleCentr.y() == 0)
assert (not anCircleCentr.isInitialized())
-aCircleRadius = aSketchCircleData.real("CircleRadius");
+aCircleRadius = aSketchCircle.real("CircleRadius")
assert (type(aCircleRadius) == ModelAPI_AttributeDouble)
# ModelAPI_AttributeDouble.type() is checked in ModelAPI_TestConstants
assert (aCircleRadius.attributeType() == ModelAPI_AttributeDouble.type())
assert (anCircleCentr.y() == -25)
assert (aCircleRadius.value() == 25)
aSession.finishOperation()
-#===============================================================================
+#=========================================================================
# Edit the Cricle
# 1. Check that changing the centr of a circle does not affects radius
# 2. and vise versa; also check that int is acceptable as well as a real
-#===============================================================================
+#=========================================================================
aSession.startOperation()
anCircleCentr.setValue(10, 60)
aSession.finishOperation()
assert (anCircleCentr.x() == 10)
assert (anCircleCentr.y() == 60)
assert (aCircleRadius.value() == 20)
-#===============================================================================
+#=========================================================================
# End of test
-#===============================================================================
+#=========================================================================
from GeomDataAPI import *
from ModelAPI import *
-__updated__ = "2014-07-24"
+__updated__ = "2014-10-28"
aSession = ModelAPI_Session.get()
aDocument = aSession.moduleDocument()
# Creation of a sketch
#=========================================================================
aSession.startOperation()
-aSketchFeature = aDocument.addFeature("Sketch")
+aSketchCommonFeature = aDocument.addFeature("Sketch")
+aSketchFeature = modelAPI_CompositeFeature(aSketchCommonFeature)
assert (aSketchFeature.getKind() == "Sketch")
-aSketchFeatureData = aSketchFeature.data()
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
origin.setValue(0, 0, 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
dirx.setValue(1, 0, 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
diry.setValue(0, 1, 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
norm.setValue(0, 0, 1)
aSession.finishOperation()
# check that values have been changed
-origin = geomDataAPI_Point(aSketchFeatureData.attribute("Origin"))
+origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
assert (origin.x() == 0)
assert (origin.y() == 0)
assert (origin.z() == 0)
-dirx = geomDataAPI_Dir(aSketchFeatureData.attribute("DirX"))
+dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
assert (dirx.x() == 1)
assert (dirx.y() == 0)
assert (dirx.z() == 0)
-diry = geomDataAPI_Dir(aSketchFeatureData.attribute("DirY"))
+diry = geomDataAPI_Dir(aSketchFeature.attribute("DirY"))
assert (diry.x() == 0)
assert (diry.y() == 1)
assert (diry.z() == 0)
-norm = geomDataAPI_Dir(aSketchFeatureData.attribute("Norm"))
+norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
assert (norm.x() == 0)
assert (norm.y() == 0)
assert (norm.z() == 1)
# Creation of a point
#=========================================================================
aSession.startOperation()
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
assert (not aSketchReflist.isInitialized())
assert(aSketchReflist.size() == 0)
assert (len(aSketchReflist.list()) == 0)
-aSketchPoint = aDocument.addFeature("SketchPoint")
+# aSketchPoint = aDocument.addFeature("SketchPoint")
+aSketchPoint = aSketchFeature.addFeature("SketchPoint")
assert (aSketchPoint.getKind() == "SketchPoint")
-aSketchReflist.append(aSketchPoint)
-aSketchPointData = aSketchPoint.data()
-coords = geomDataAPI_Point2D(aSketchPointData.attribute("PointCoordindates"))
+coords = geomDataAPI_Point2D(aSketchPoint.attribute("PointCoordindates"))
assert (coords.x() == 0)
assert (coords.y() == 0)
assert (not coords.isInitialized())
assert (coords.isInitialized())
aSession.finishOperation()
# check that values have been changed
-aSketchReflist = aSketchFeatureData.reflist("Features")
+aSketchReflist = aSketchFeature.reflist("Features")
assert (aSketchReflist.size() == 1)
assert (len(aSketchReflist.list()) == 1)
-aSketchPointData = aSketchPoint.data()
-coords = geomDataAPI_Point2D(aSketchPointData.attribute("PointCoordindates"))
+coords = geomDataAPI_Point2D(aSketchPoint.attribute("PointCoordindates"))
assert (coords.x() == 10.0)
assert (coords.y() == 10.0)
-#===============================================================================
+#=========================================================================
# Creation of a line
-#===============================================================================
+#=========================================================================
aSession.startOperation()
-aSketchLine = aDocument.addFeature("SketchLine")
+# aSketchLine = aDocument.addFeature("SketchLine")
+aSketchLine = aSketchFeature.addFeature("SketchLine")
assert (aSketchLine.getKind() == "SketchLine")
-aSketchReflist.append(aSketchLine)
assert (aSketchReflist.size() == 2)
assert (len(aSketchReflist.list()) == 2)
-aSketchLineData = aSketchLine.data()
-aLineStartPoint = geomDataAPI_Point2D(aSketchLineData.attribute("StartPoint"))
-aLineEndPoint= geomDataAPI_Point2D(aSketchLineData.attribute("EndPoint"))
+aLineStartPoint = geomDataAPI_Point2D(aSketchLine.attribute("StartPoint"))
+aLineEndPoint = geomDataAPI_Point2D(aSketchLine.attribute("EndPoint"))
assert (aLineStartPoint.x() == 0)
assert (aLineStartPoint.y() == 0)
assert (not aLineStartPoint.isInitialized())
assert (aLineEndPoint.isInitialized())
aSession.finishOperation()
# check that values have been changed
-aSketchLineData = aSketchLine.data()
-aLineStartPoint = geomDataAPI_Point2D(aSketchLineData.attribute("StartPoint"))
-aLineEndPoint= geomDataAPI_Point2D(aSketchLineData.attribute("EndPoint"))
+aLineStartPoint = geomDataAPI_Point2D(aSketchLine.attribute("StartPoint"))
+aLineEndPoint = geomDataAPI_Point2D(aSketchLine.attribute("EndPoint"))
assert (aLineStartPoint.x() == 50.0)
assert (aLineStartPoint.y() == 50.0)
assert (aLineEndPoint.x() == 60.0)
assert (aLineEndPoint.y() == 60.0)
-#===============================================================================
+#=========================================================================
# Check the results
-#===============================================================================
+#=========================================================================
aResult = aSketchLine.firstResult()
+assert (aResult is not None)
aResultConstruction = modelAPI_ResultConstruction(aResult)
aShape = aResultConstruction.shape()
assert (aShape is not None)
QString aToolTip = toolTip();
if (!aKeys.isEmpty()) {
aToolTip = QString("%1 (%2)").arg(aToolTip).arg(aKeys.toString());
+ aButton->setShortcut(aKeys);
}
if (!aToolTip.isEmpty()) {
aButton->setToolTip(aToolTip);
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Session.h>
#include <QAction>
#include <QContextMenuEvent>
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:
XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent)
: QObject(theParent)
{
- // listen to Escape signal to stop the current operation
- qApp->installEventFilter(this);
}
XGUI_OperationMgr::~XGUI_OperationMgr()
{
if (theEvent->type() == QEvent::KeyRelease) {
QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
- if(aKeyEvent && onKeyReleased(aKeyEvent)) {
- return true;
+ if(aKeyEvent) {
+ return onKeyReleased(aKeyEvent);
}
}
return QObject::eventFilter(theObject, theEvent);
ModuleBase_Operation* anOperation = currentOperation();
bool isAccepted = true;
switch (theEvent->key()) {
- case Qt::Key_Escape: {
- onAbortOperation();
- }
- break;
case Qt::Key_Return:
case Qt::Key_Enter: {
commitOperation();
aBtn->setToolTip(tr("Cancel"));
aBtn->setObjectName(XGUI::PROP_PANEL_CANCEL);
aBtn->setFlat(true);
+ aBtn->setShortcut(QKeySequence(Qt::Key_Escape));
aBtnLay->addWidget(aBtn);
myCustomWidget = new QWidget(aContent);
/// 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)) {
hidePropertyPanel(); //<! Invisible by default
hideObjectBrowser();
aDesktop->tabifyDockWidget(aObjDock, myPropertyPanel);
+ myPropertyPanel->installEventFilter(myOperationMgr);
QPushButton* aOkBtn = myPropertyPanel->findChild<QPushButton*>(XGUI::PROP_PANEL_OK);
connect(aOkBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onCommitOperation()));
