const static char* WDG_SHAPE_SELECTOR = "shape_selector";
const static char* WDG_CHOICE = "choice";
//Specific widgets
-const static char* WDG_POINT_SELECTOR = "point_selector";
-const static char* WDG_POINT2D_DISTANCE = "point2ddistance";
-const static char* WDG_FEATURE_SELECTOR = "feature_selector";
-const static char* WDG_FEATURE_OR_ATTRIBUTE_SELECTOR = "feature_or_attribute_selector";
+//const static char* WDG_POINT2D_DISTANCE = "point2ddistance";
+//const static char* WDG_FEATURE_SELECTOR = "feature_selector";
+//const static char* WDG_FEATURE_OR_ATTRIBUTE_SELECTOR = "feature_or_attribute_selector";
const static char* WDG_DOUBLEVALUE_EDITOR = "doublevalue_editor";
const static char* WDG_FILE_SELECTOR= "file_selector";
const static char* ATTRIBUTE_OBLIGATORY = "obligatory";
const static char* ATTRIBUTE_CONCEALMENT = "concealment";
// TODO: Rename
-const static char* PREVIOUS_FEATURE_PARAM = "previous_feature_param";
+//const static char* PREVIOUS_FEATURE_PARAM = "previous_feature_param";
const static char* ANY_WDG_TOOLTIP = FEATURE_TOOLTIP;
const static char* ANY_WDG_ICON = FEATURE_ICON;
const static char* ANY_WDG_LABEL = "label";
ModuleBase_WidgetDoubleValue.h
ModuleBase_WidgetEditor.h
ModuleBase_WidgetFactory.h
- ModuleBase_WidgetFeature.h
- ModuleBase_WidgetFeatureOrAttribute.h
- ModuleBase_WidgetPoint2D.h
+# ModuleBase_WidgetFeature.h
+# ModuleBase_WidgetFeatureOrAttribute.h
ModuleBase_WidgetSwitch.h
ModuleBase_WidgetShapeSelector.h
ModuleBase_IWorkshop.h
- ModuleBase_WidgetPoint2dDistance.h
ModuleBase_WidgetValue.h
ModuleBase_WidgetValueFeature.h
ModuleBase_Definitions.h
ModuleBase_WidgetMultiSelector.h
ModuleBase_ViewerFilters.h
ModuleBase_ResultPrs.h
+ ModuleBase_IViewWindow.h
)
SET(PROJECT_SOURCES
ModuleBase_WidgetDoubleValue.cpp
ModuleBase_WidgetEditor.cpp
ModuleBase_WidgetFactory.cpp
- ModuleBase_WidgetFeature.cpp
- ModuleBase_WidgetFeatureOrAttribute.cpp
- ModuleBase_WidgetPoint2D.cpp
+# ModuleBase_WidgetFeature.cpp
+# ModuleBase_WidgetFeatureOrAttribute.cpp
ModuleBase_WidgetSwitch.cpp
ModuleBase_WidgetShapeSelector.cpp
- ModuleBase_WidgetPoint2dDistance.cpp
ModuleBase_WidgetValue.cpp
ModuleBase_WidgetValueFeature.cpp
ModuleBase_WidgetChoice.cpp
#define ModuleBase_Definitions_H
#include <QList>
-#include <ModelAPI_Feature.h>
+#include <ModelAPI_Object.h>
typedef QList<int> QIntList; //!< list of int values
typedef QList<short> QShortList; //!< list of short int values
typedef QList<double> QDoubleList; //!< list of double values
-typedef QList<FeaturePtr> QFeatureList; //!< List of features
+typedef QList<ObjectPtr> QObjectPtrList; //!< List of ModelAPI_Objects
#endif
#include "ModuleBase_ViewerPrs.h"
#include "ModuleBase_Operation.h"
#include "ModuleBase_ISelection.h"
+#include "ModuleBase_OperationDescription.h"
#include <Events_Loop.h>
#include <ModelAPI_Events.h>
+#include <ModelAPI_CompositeFeature.h>
#include <Config_PointerMessage.h>
+#include <Config_WidgetReader.h>
+#include <Config_ModuleReader.h>
+#include <QAction>
ModuleBase_IModule::ModuleBase_IModule(ModuleBase_IWorkshop* theParent)
: QObject(theParent), myWorkshop(theParent)
{
+ connect(myWorkshop, SIGNAL(operationStarted(ModuleBase_Operation*)),
+ SLOT(onOperationStarted(ModuleBase_Operation*)));
+
+ connect(myWorkshop, SIGNAL(operationStopped(ModuleBase_Operation*)),
+ SLOT(onOperationStopped(ModuleBase_Operation*)));
+
+ connect(myWorkshop, SIGNAL(operationResumed(ModuleBase_Operation*)),
+ SLOT(onOperationResumed(ModuleBase_Operation*)));
+
+ connect(myWorkshop, SIGNAL(operationComitted(ModuleBase_Operation*)),
+ SLOT(onOperationComitted(ModuleBase_Operation*)));
+
+ connect(myWorkshop, SIGNAL(operationAborted(ModuleBase_Operation*)),
+ SLOT(onOperationAborted(ModuleBase_Operation*)));
+
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*)));
+
+
+ //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)
{
+ if (!myWorkshop->canStartOperation(theCmdId))
+ return;
+
ModuleBase_Operation* anOperation = createOperation(theCmdId.toStdString());
ModuleBase_ISelection* aSelection = myWorkshop->selection();
// Initialise operation with preliminary selection
aMessage->setPointer(theOperation);
Events_Loop::loop()->send(aMessage);
}
+
+ModuleBase_Operation* ModuleBase_IModule::getNewOperation(const std::string& theFeatureId)
+{
+ return new ModuleBase_Operation(theFeatureId.c_str(), this);
+}
+
+ModuleBase_Operation* ModuleBase_IModule::createOperation(const std::string& theFeatureId)
+{
+ ModuleBase_Operation* anOperation = getNewOperation(theFeatureId);
+
+ // If the operation is launched as sub-operation of another then we have to initialise
+ // parent feature
+ ModuleBase_Operation* aCurOperation = myWorkshop->currentOperation();
+ if (aCurOperation) {
+ FeaturePtr aFeature = aCurOperation->feature();
+ CompositeFeaturePtr aCompFea = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
+ if (aCompFea)
+ anOperation->setParentFeature(aCompFea);
+ }
+
+ std::string aPluginFileName = myFeaturesInFiles[theFeatureId];
+ Config_WidgetReader aWdgReader = Config_WidgetReader(aPluginFileName);
+ aWdgReader.readAll();
+ std::string aXmlCfg = aWdgReader.featureWidgetCfg(theFeatureId);
+ std::string aDescription = aWdgReader.featureDescription(theFeatureId);
+
+ anOperation->getDescription()->setDescription(QString::fromStdString(aDescription));
+ anOperation->getDescription()->setXmlRepresentation(QString::fromStdString(aXmlCfg));
+
+ return anOperation;
+}
+
+void ModuleBase_IModule::createFeatures()
+{
+ registerValidators();
+
+ Config_ModuleReader aXMLReader = Config_ModuleReader();
+ aXMLReader.readAll();
+ myFeaturesInFiles = aXMLReader.featuresInFiles();
+}
+
+
+void ModuleBase_IModule::actionCreated(QAction* theFeature)
+{
+ connect(theFeature, SIGNAL(triggered(bool)), this, SLOT(onFeatureTriggered()));
+}
+
+
+void ModuleBase_IModule::onFeatureTriggered()
+{
+ QAction* aCmd = dynamic_cast<QAction*>(sender());
+ //Do nothing on uncheck
+ if (aCmd->isCheckable() && !aCmd->isChecked())
+ return;
+ launchOperation(aCmd->data().toString());
+}
+
+
+void ModuleBase_IModule::editFeature(FeaturePtr theFeature)
+{
+ ModuleBase_Operation* anOperation = createOperation(theFeature->getKind());
+ anOperation->setFeature(theFeature);
+ sendOperation(anOperation);
+}
\ No newline at end of file
#include "ModuleBase.h"\r
#include "ModuleBase_IWorkshop.h"\r
\r
+#include <ModelAPI_Feature.h>\r
+\r
#include <QString>\r
#include <QObject>\r
\r
+#include <string>\r
+#include <map>\r
\r
class QAction;\r
class QMouseEvent;\r
virtual ~ModuleBase_IModule() {}\r
\r
/// Reads description of features from XML file \r
- virtual void createFeatures() = 0;\r
+ virtual void createFeatures();\r
\r
/// Called on creation of menu item in desktop\r
- virtual void featureCreated(QAction*) = 0;\r
+ virtual void actionCreated(QAction*);\r
+\r
+ /// Called when user selects feature for editing\r
+ virtual void editFeature(FeaturePtr theFeature);\r
\r
/// Creates an operation and send it to loop\r
/// \param theCmdId the operation name\r
\r
/// Creates custom widgets for property panel\r
virtual QWidget* createWidgetByType(const std::string& theType, QWidget* theParent,\r
- Config_WidgetAPI* theWidgetApi,\r
+ Config_WidgetAPI* theWidgetApi, std::string theParentId,\r
QList<ModuleBase_ModelWidget*>& theModelWidgets)\r
{\r
return 0;\r
\r
ModuleBase_IWorkshop* workshop() const { return myWorkshop; }\r
\r
+ /// Call back forlast tuning of property panel before operation performance\r
+ /// It is called as on clearing of property panel as on filling with new widgets\r
+ virtual void propertyPanelDefined(ModuleBase_Operation* theOperation) {}\r
+\r
+public slots:\r
+ void onFeatureTriggered();\r
+\r
protected slots:\r
+ /// SLOT, that is called after the operation is started. Connect on the focus activated signal\r
+ virtual void onOperationStarted(ModuleBase_Operation* theOperation) {}\r
+ \r
+ /// SLOT, that is called after the operation is stopped. Switched off the modfications performed\r
+ /// by the operation start\r
+ virtual void onOperationStopped(ModuleBase_Operation* theOperation) {}\r
+\r
+ virtual void onOperationResumed(ModuleBase_Operation* theOperation) {}\r
+\r
+ virtual void onOperationComitted(ModuleBase_Operation* theOperation) {}\r
+\r
+ virtual void onOperationAborted(ModuleBase_Operation* theOperation) {}\r
+\r
\r
/// Called on selection changed event\r
virtual void onSelectionChanged() {}\r
/// 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
+ //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
+ //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
+ //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
+ //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
+ //virtual void onKeyRelease(QKeyEvent* theEvent) {}\r
\r
protected:\r
/// Sends the operation for launching\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
+ virtual ModuleBase_Operation* createOperation(const std::string& theFeatureId);\r
+\r
+ /// Register validators for this module\r
+ virtual void registerValidators() {}\r
\r
+ /// Returns new instance of operation object (used in createOperation for customization)\r
+ virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);\r
\r
protected:\r
\r
ModuleBase_IWorkshop* myWorkshop;\r
-\r
+ std::map<std::string, std::string> myFeaturesInFiles;\r
};\r
\r
+\r
+\r
//! This function must return a new module instance.\r
extern "C" {\r
typedef ModuleBase_IModule* (*CREATE_FUNC)(ModuleBase_IWorkshop*);\r
/// The signal about key release on the control, that corresponds to the attribute
/// \param theEvent key release event
void keyReleased(QKeyEvent* theEvent);
+
/// The signal about the widget activation
/// \param theWidget the activated widget
void widgetActivated(ModuleBase_ModelWidget* theWidget);
+ /// Emited when there is no next widget
+ void noMoreWidgets();
+
public slots:
/// Activate the next widget in the property panel
/// \param theWidget a widget. The next widget should be activated
virtual QList<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const = 0;
/**
- * Returns list of features currently selected in 3d viewer
+ * Returns list of features currently selected in object browser
*/
- virtual QList<ObjectPtr> selectedObjects() const = 0;
+ virtual QObjectPtrList selectedObjects() const = 0;
/**
* Returns list of currently selected results
*/
- virtual QList<ObjectPtr> selectedPresentations() const = 0;
+ virtual QObjectPtrList selectedPresentations() const = 0;
//! Returns list of currently selected QModelIndexes
virtual QModelIndexList selectedIndexes() const = 0;
--- /dev/null
+
+
+#ifndef ModuleBase_IViewWindow_H
+#define ModuleBase_IViewWindow_H
+
+#include <V3d_View.hxx>
+
+
+/**
+* Interface to ViewWindow object which contains 3d scene
+*/
+class ModuleBase_IViewWindow
+{
+public:
+ /// Returns OCCT object which contains 3d view object
+ virtual Handle(V3d_View) v3dView() const = 0;
+};
+
+
+#endif
\ No newline at end of file
class QMouseEvent;
class QKeyEvent;
class QContextMenuEvent;
+class ModuleBase_IViewWindow;
/**
* A Base object for definition of connector object to
signals:
void lastViewClosed();
- void tryCloseView();
- void deleteView();
- void viewCreated();
- void mousePress(QMouseEvent* theEvent);
- void mouseRelease(QMouseEvent* theEvent);
- void mouseDoubleClick(QMouseEvent* theEvent);
- void mouseMove(QMouseEvent* theEvent);
- void keyPress(QKeyEvent* theEvent);
- void keyRelease(QKeyEvent* theEvent);
- void activated();
+ void tryCloseView(ModuleBase_IViewWindow* theWnd);
+ void deleteView(ModuleBase_IViewWindow* theWnd);
+ void viewCreated(ModuleBase_IViewWindow* theWnd);
+ void activated(ModuleBase_IViewWindow* theWnd);
+
+ void mousePress(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+ void mouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+ void mouseDoubleClick(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+ void mouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+
+ void keyPress(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent);
+ void keyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent);
void selectionChanged();
void contextMenuRequested(QContextMenuEvent*);
//! Returns currently active operation
virtual ModuleBase_Operation* currentOperation() const = 0;
+ //! Returns true if the operation with id theId can be started
+ virtual bool canStartOperation(QString theId) = 0;
+
//! Returns AIS opbject by data object
virtual AISObjectPtr findPresentation(const ObjectPtr& theObject) 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;
+ virtual void setSelected(const QObjectPtrList& theFeatures) = 0;
signals:
void selectionChanged();
- void operationStarted(ModuleBase_Operation*);
- void operationStopped(ModuleBase_Operation*);
+ /// Signal about an operation is started. It is emitted after the start() of operation is done.
+ void operationStarted(ModuleBase_Operation* theOperation);
+
+ /// Signal about an operation is stopped. It is emitted after the stop() of operation is done.
+ /// \param theOperation a stopped operation
+ void operationStopped(ModuleBase_Operation* theOperation);
+
+ /// Signal about an operation is resumed. It is emitted after the resume() of operation is done.
+ void operationResumed(ModuleBase_Operation* theOperation);
+
+ /// Emitted when current operation is comitted
+ void operationComitted(ModuleBase_Operation* theOperation);
+
+ /// Emitted when current operation is aborted
+ void operationAborted(ModuleBase_Operation* theOperation);
+
+ /// Signal which is emited after activation of property panel
+ void propertyPanelActivated();
+
};
#endif
return true;
}
-void ModuleBase_Operation::storeCustomValue()
-{
- if (!myFeature) {
-#ifdef _DEBUG
- qDebug() << "ModuleBase_Operation::storeCustom: " <<
- "trying to store value without opening a transaction.";
-#endif
- return;
- }
-
- ModuleBase_ModelWidget* aCustom = dynamic_cast<ModuleBase_ModelWidget*>(sender());
- if (aCustom)
- aCustom->storeValue();
-}
-
-void ModuleBase_Operation::startOperation()
-{
- if (!myIsEditing)
- createFeature();
-}
-
-void ModuleBase_Operation::stopOperation()
-{
-}
+//void ModuleBase_Operation::storeCustomValue()
+//{
+// if (!myFeature) {
+//#ifdef _DEBUG
+// qDebug() << "ModuleBase_Operation::storeCustom: " <<
+// "trying to store value without opening a transaction.";
+//#endif
+// return;
+// }
+//
+// ModuleBase_ModelWidget* aCustom = dynamic_cast<ModuleBase_ModelWidget*>(sender());
+// if (aCustom)
+// aCustom->storeValue();
+//}
-void ModuleBase_Operation::abortOperation()
-{
-}
-
-void ModuleBase_Operation::commitOperation()
-{
-}
-
-void ModuleBase_Operation::afterCommitOperation()
-{
-}
bool ModuleBase_Operation::canBeCommitted() const
{
return isValid();
}
-
-void ModuleBase_Operation::flushUpdated()
-{
- Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
-}
+//
+//void ModuleBase_Operation::flushUpdated()
+//{
+// Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+//}
void ModuleBase_Operation::flushCreated()
{
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
}
-FeaturePtr ModuleBase_Operation::createFeature(
- const bool theFlushMessage, CompositeFeaturePtr theCompositeFeature)
+FeaturePtr ModuleBase_Operation::createFeature(const bool theFlushMessage)
{
- if (theCompositeFeature) {
- myFeature = theCompositeFeature->addFeature(getDescription()->operationId().toStdString());
+ if (myParentFeature) {
+ myFeature = myParentFeature->addFeature(getDescription()->operationId().toStdString());
} else {
std::shared_ptr<ModelAPI_Document> aDoc = document();
myFeature = aDoc->addFeature(getDescription()->operationId().toStdString());
std::list<ResultPtr> aResults = aFeature->results();
std::list<ResultPtr>::const_iterator aIt;
for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
- if ((*aIt) == theObj)
+ if (theObj == (*aIt))
return true;
}
}
{
ModelAPI_Session::get()->startOperation();
+ if (!myIsEditing)
+ createFeature();
+
startOperation();
emit started();
}
+void ModuleBase_Operation::postpone()
+{
+ if (myPropertyPanel)
+ disconnect(myPropertyPanel, 0, this, 0);
+ emit postponed();
+}
+
void ModuleBase_Operation::resume()
{
if (myPropertyPanel)
- connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)),
- this, SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
+ connect(myPropertyPanel, SIGNAL(noMoreWidgets()), SLOT(commit()));
+ // connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)),
+ // this, SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
emit resumed();
}
bool ModuleBase_Operation::commit()
{
if (canBeCommitted()) {
- commitOperation();
- emit committed();
-
- if (myPropertyPanel)
- disconnect(myPropertyPanel, 0, this, 0);
+ if (myPropertyPanel)
+ disconnect(myPropertyPanel, 0, this, 0);
- stopOperation();
+ commitOperation();
// check whether there are modifications performed during the current operation
// in the model
// in case if there are no modifications, do not increase the undo/redo stack
else
ModelAPI_Session::get()->abortOperation();
+ stopOperation();
emit stopped();
+ emit committed();
afterCommitOperation();
return true;
QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
std::list<ResultPtr> aResults = aFeature->results();
- QList<ObjectPtr> aResList;
+ QObjectPtrList aResList;
std::list<ResultPtr>::const_iterator aIt;
for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt)
aResList.append(*aIt);
}
}
-void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
-{
- //activateByPreselection();
- //if (theWidget && myPropertyPanel) {
- // myPropertyPanel->activateNextWidget();
- //// //emit activateNextWidget(myActiveWidget);
- //}
-}
-
-bool ModuleBase_Operation::setWidgetValue(ObjectPtr theFeature, double theX, double theY)
-{
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- if (!aActiveWgt)
- return false;
- ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
- aValue->setObject(theFeature);
- aValue->setPoint(std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY)));
- bool isApplyed = aActiveWgt->setValue(aValue);
-
- delete aValue;
- myIsModified = (myIsModified || isApplyed);
- return isApplyed;
-}
+//void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
+//{
+// //activateByPreselection();
+// //if (theWidget && myPropertyPanel) {
+// // myPropertyPanel->activateNextWidget();
+// //// //emit activateNextWidget(myActiveWidget);
+// //}
+//}
+
+//bool ModuleBase_Operation::setWidgetValue(ObjectPtr theFeature, double theX, double theY)
+//{
+// ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
+// if (!aActiveWgt)
+// return false;
+// ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
+// aValue->setObject(theFeature);
+// aValue->setPoint(std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY)));
+// bool isApplyed = aActiveWgt->setValue(aValue);
+//
+// delete aValue;
+// myIsModified = (myIsModified || isApplyed);
+// return isApplyed;
+//}
bool ModuleBase_Operation::getViewerPoint(ModuleBase_ViewerPrs thePrs,
ModuleBase_IViewer* theViewer,
void ModuleBase_Operation::setPropertyPanel(ModuleBase_IPropertyPanel* theProp)
{
myPropertyPanel = theProp;
- connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), this,
- SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
+ //connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), this,
+ // SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
+ if (myPropertyPanel) {
+ connect(myPropertyPanel, SIGNAL(noMoreWidgets()), SLOT(commit()));
+ }
}
+
+bool ModuleBase_Operation::isGranted(QString theId) const
+{
+ return myNestedFeatures.contains(theId);
+}
\ No newline at end of file
* the operation is not granted.
* The method has to be redefined for granted operations.
*/
- virtual bool isGranted(ModuleBase_Operation* theOperation) const { return false; }
+ virtual bool isGranted(QString theId) const;
/// Sets a list of model widgets, according to the operation feature xml definition
/// \param theXmlRepresentation an xml feature definition
/// Returns True if the current operation works with the given object (feature or result)
virtual bool hasObject(ObjectPtr theObj) const;
- virtual void keyReleased(const int theKey) {};
+ //virtual void keyReleased(const int theKey) {};
/// If operation needs to redisplay its result during operation
/// then this method has to return True
- virtual bool hasPreview() const { return false; }
+ //virtual bool hasPreview() const { return false; }
/// Initialisation of operation with preliminary selection
/// \param theSelected the list of selected presentations
/// Activates widgets by preselection if it is accepted
virtual bool activateByPreselection();
+ /// If the operation works with feature which is sub-feature of another one
+ /// then this variable has to be initialised by parent feature
+ /// before operation feature creating
+ void setParentFeature(CompositeFeaturePtr theParent) { myParentFeature = theParent; }
+ CompositeFeaturePtr parentFeature() const { return myParentFeature; }
+
signals:
void started(); /// the operation is started
void aborted(); /// the operation is aborted
void committed(); /// the operation is committed
void stopped(); /// the operation is aborted or committed
void resumed(); /// the operation is resumed
+ void postponed(); /// the operation is postponed
public slots:
/// Starts operation
/// be better to inherit own operator from base one and redefine startOperation method
/// instead.
void start();
+
+ /// Deactivates current operation which can be resumed later.
+ void postpone();
+
/// Resumes operation
/// Public slot. Verifies whether operation can be started and starts operation.
/// This slot is not virtual and cannot be redefined. Redefine startOperation method
/// be better to inherit own operator from base one and redefine startOperation method
/// instead.
void resume();
+
/// Aborts operation
/// Public slot. Aborts operation. This slot is not virtual and cannot be redefined.
/// Redefine abortOperation method to change behavior of operation instead
void abort();
+
/// Commits operation
/// Public slot. Commits operation. This slot is not virtual and cannot be redefined.
/// Redefine commitOperation method to change behavior of operation instead
// Data model methods.
/// Stores a custom value in model.
- virtual void storeCustomValue();
+ //virtual void storeCustomValue();
/// Slots which listen the mode widget activation
/// \param theWidget the model widget
- virtual void onWidgetActivated(ModuleBase_ModelWidget* theWidget);
+ //virtual void onWidgetActivated(ModuleBase_ModelWidget* theWidget);
protected:
/// Virtual method called when operation started (see start() method for more description)
/// Default impl calls corresponding slot and commits immediately.
- virtual void startOperation();
+ virtual void startOperation() {}
+
+ /// Implementation of specific steps on postpone operation
+ virtual void postponeOperation() {}
/// Virtual method called when operation stopped - committed or aborted.
- virtual void stopOperation();
+ virtual void stopOperation() {}
/// Virtual method called when operation aborted (see abort() method for more description)
- virtual void abortOperation();
+ virtual void abortOperation() {}
/// Virtual method called when operation committed (see commit() method for more description)
- virtual void commitOperation();
+ virtual void commitOperation() {}
/// Virtual method called after operation committed (see commit() method for more description)
- virtual void afterCommitOperation();
+ virtual void afterCommitOperation() {}
/// Send update message by loop
- void flushUpdated();
+ //void flushUpdated();
+
/// Send created message by loop
void flushCreated();
/// \param theFlushMessage the flag whether the create message should be flushed
/// \param theCompositeFeature the feature that must be used for adding the created object or null
/// \returns the created
- virtual FeaturePtr createFeature(const bool theFlushMessage = true,
- CompositeFeaturePtr theCompositeFeature = CompositeFeaturePtr());
+ virtual FeaturePtr createFeature(const bool theFlushMessage = true);
/// Verifies whether this operator can be commited.
/// \return Returns TRUE if current operation can be committed, e.g. all parameters are filled
/// \param theX the horizontal coordinate
/// \param theY the vertical coordinate
/// \return true if the point is set
- virtual bool setWidgetValue(ObjectPtr theFeature, double theX, double theY);
+ //virtual bool setWidgetValue(ObjectPtr theFeature, double theX, double theY);
/// Return a widget value point by the selection and the viewer position
/// The default realization returns false
/// Access to property panel
ModuleBase_IPropertyPanel* myPropertyPanel;
+
+ /// If the operation works with feature which is sub-feature of another one
+ /// then this variable has to be initialised by parent feature
+ /// before operation feature creating
+ CompositeFeaturePtr myParentFeature;
+
};
#endif
// Author: Vitaly Smetannikov
#include "ModuleBase_Tools.h"
-#include <ModelAPI_ResultBody.h>
-#include <ModelAPI_ResultConstruction.h>
-#include <ModelAPI_Document.h>
+#include <QWidget>
+#include <QLayout>
namespace ModuleBase_Tools {
theLayout->setSpacing(5);
}
+
+
}
+
+
#include "ModuleBase.h"
-#include <QWidget>
-#include <QLayout>
-
-class GeomAPI_Shape;
+class QWidget;
+class QLayout;
namespace ModuleBase_Tools {
MODULEBASE_EXPORT void zeroMargins(QWidget* theWidget);
MODULEBASE_EXPORT void zeroMargins(QLayout* theLayout);
+
}
#endif
#include <QTimer>
#include <QDialog>
#include <QLayout>
+#include <QApplication>
ModuleBase_WidgetEditor::ModuleBase_WidgetEditor(QWidget* theParent,
const Config_WidgetAPI* theData,
bool ModuleBase_WidgetEditor::focusTo()
{
+ // We can not launch here modal process for value editing because
+ // it can be called on other focusOutWidget event and will block it
+ QTimer::singleShot(1, this, SLOT(showPopupEditor()));
+ return true;
+}
+
+void ModuleBase_WidgetEditor::showPopupEditor()
+{
+ // White while all events will be processed
+ QApplication::processEvents();
double aValue = mySpinBox->value();
bool isDone;
aValue = editedValue(aValue, isDone);
}
emit valuesChanged();
emit focusOutWidget(this);
-
- return false;
}
void ModuleBase_WidgetEditor::editFeatureValue(FeaturePtr theFeature,
/// \param theAttribute the feature attribute
static void editFeatureValue(FeaturePtr theFeature, const std::string theAttribute);
+ private slots:
+ /// Shous popup window under cursor for data editing
+ void showPopupEditor();
+
private:
FeaturePtr myFeature; ///< the current widget feature
QStringList myFeatureKinds; ///< the kinds of possible features
#include <ModuleBase_Operation.h>
#include <ModuleBase_OperationDescription.h>
-#include <ModuleBase_WidgetPoint2D.h>
-#include <ModuleBase_WidgetFeatureOrAttribute.h>
-#include <ModuleBase_WidgetFeature.h>
+//#include <ModuleBase_WidgetFeatureOrAttribute.h>
+//#include <ModuleBase_WidgetFeature.h>
#include <ModuleBase_WidgetEditor.h>
#include <ModuleBase_WidgetSwitch.h>
#include <ModuleBase_WidgetShapeSelector.h>
#include <ModuleBase_WidgetDoubleValue.h>
#include <ModuleBase_WidgetBoolValue.h>
-#include <ModuleBase_WidgetPoint2dDistance.h>
+//#include <ModuleBase_WidgetPoint2dDistance.h>
#include <ModuleBase_WidgetFileSelector.h>
#include <ModuleBase_WidgetChoice.h>
#include <ModuleBase_IWorkshop.h>
} else if (theType == WDG_BOOLVALUE) {
result = booleanControl(theParent);
- } else if (theType == WDG_POINT_SELECTOR) {
- result = pointSelectorControl(theParent);
+ //} else if (theType == WDG_FEATURE_SELECTOR) {
+ // result = featureSelectorControl(theParent);
- } else if (theType == WDG_FEATURE_SELECTOR) {
- result = featureSelectorControl(theParent);
-
- } else if (theType == WDG_FEATURE_OR_ATTRIBUTE_SELECTOR) {
- result = featureOrAttributeSelectorControl(theParent);
+ //} else if (theType == WDG_FEATURE_OR_ATTRIBUTE_SELECTOR) {
+ // result = featureOrAttributeSelectorControl(theParent);
} else if (theType == WDG_DOUBLEVALUE_EDITOR) {
result = doubleValueEditor(theParent);
- } else if (theType == WDG_POINT2D_DISTANCE) {
- result = point2dDistanceControl(theParent);
-
} else if (theType == WDG_FILE_SELECTOR) {
result = fileSelectorControl(theParent);
result = createContainer(theType, theParent);
} else {
result = myWorkshop->module()->createWidgetByType(theType, theParent, myWidgetApi,
- myModelWidgets);
+ myParentId, myModelWidgets);
#ifdef _DEBUG
if (!result) {qDebug("ModuleBase_WidgetFactory::fillWidget: find bad widget type");}
#endif
return aDblWgt->getControl();
}
-QWidget* ModuleBase_WidgetFactory::pointSelectorControl(QWidget* theParent)
-{
- ModuleBase_WidgetPoint2D* aWidget =
- new ModuleBase_WidgetPoint2D(theParent, myWidgetApi,myParentId);
- myModelWidgets.append(aWidget);
- return aWidget->getControl();
-}
-
-QWidget* ModuleBase_WidgetFactory::featureSelectorControl(QWidget* theParent)
-{
- ModuleBase_WidgetFeature* aWidget =
- new ModuleBase_WidgetFeature(theParent, myWidgetApi,myParentId);
- myModelWidgets.append(aWidget);
- return aWidget->getControl();
-}
-
-QWidget* ModuleBase_WidgetFactory::featureOrAttributeSelectorControl(QWidget* theParent)
-{
- ModuleBase_WidgetFeatureOrAttribute* aWidget =
- new ModuleBase_WidgetFeatureOrAttribute(theParent, myWidgetApi, myParentId);
- myModelWidgets.append(aWidget);
- return aWidget->getControl();
-}
+//QWidget* ModuleBase_WidgetFactory::featureSelectorControl(QWidget* theParent)
+//{
+// ModuleBase_WidgetFeature* aWidget =
+// new ModuleBase_WidgetFeature(theParent, myWidgetApi,myParentId);
+// myModelWidgets.append(aWidget);
+// return aWidget->getControl();
+//}
+
+//QWidget* ModuleBase_WidgetFactory::featureOrAttributeSelectorControl(QWidget* theParent)
+//{
+// ModuleBase_WidgetFeatureOrAttribute* aWidget =
+// new ModuleBase_WidgetFeatureOrAttribute(theParent, myWidgetApi, myParentId);
+// myModelWidgets.append(aWidget);
+// return aWidget->getControl();
+//}
QWidget* ModuleBase_WidgetFactory::doubleValueEditor(QWidget* theParent)
{
return aBoolWgt->getControl();
}
-QWidget* ModuleBase_WidgetFactory::point2dDistanceControl(QWidget* theParent)
-{
- ModuleBase_WidgetPoint2dDistance* aDistWgt =
- new ModuleBase_WidgetPoint2dDistance(theParent, myWidgetApi, myParentId);
- myModelWidgets.append(aDistWgt);
- return aDistWgt->getControl();
-}
-
QWidget* ModuleBase_WidgetFactory::fileSelectorControl(QWidget* theParent)
{
ModuleBase_WidgetFileSelector* aFileSelectorWgt =
QWidget* createContainer(const std::string& theType, QWidget* theParent = NULL);
QWidget* labelControl(QWidget* theParent);
QWidget* doubleSpinBoxControl(QWidget* theParent);
- QWidget* pointSelectorControl(QWidget* theParent);
- QWidget* featureSelectorControl(QWidget* theParent);
- QWidget* featureOrAttributeSelectorControl(QWidget* theParent);
+ //QWidget* featureSelectorControl(QWidget* theParent);
+ //QWidget* featureOrAttributeSelectorControl(QWidget* theParent);
QWidget* doubleValueEditor(QWidget* theParent);
QWidget* shapeSelectorControl(QWidget* theParent);
QWidget* booleanControl(QWidget* theParent);
- QWidget* point2dDistanceControl(QWidget* theParent);
QWidget* fileSelectorControl(QWidget* theParent);
QWidget* choiceControl(QWidget* theParent);
QWidget* lineEditControl(QWidget* theParent);
+++ /dev/null
-// File: ModuleBase_WidgetFeature.cpp
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <ModuleBase_WidgetFeature.h>
-
-#include <ModuleBase_WidgetValueFeature.h>
-#include <ModuleBase_WidgetValue.h>
-#include <ModuleBase_Tools.h>
-
-#include <Config_Keywords.h>
-#include <Config_WidgetAPI.h>
-
-#include <Events_Loop.h>
-
-#include <ModelAPI_Events.h>
-#include <ModelAPI_Feature.h>
-#include <ModelAPI_Data.h>
-#include <ModelAPI_Object.h>
-#include <ModelAPI_AttributeRefAttr.h>
-#include <ModelAPI_Validator.h>
-#include <ModelAPI_ResultValidator.h>
-#include <ModelAPI_RefAttrValidator.h>
-#include <ModelAPI_Session.h>
-
-#include <QWidget>
-#include <QLineEdit>
-#include <QHBoxLayout>
-#include <QLabel>
-
-ModuleBase_WidgetFeature::ModuleBase_WidgetFeature(QWidget* theParent,
- const Config_WidgetAPI* theData,
- const std::string& theParentId)
- : ModuleBase_ModelWidget(theParent, theData, theParentId)
-{
- myContainer = new QWidget(theParent);
- QHBoxLayout* aControlLay = new QHBoxLayout(myContainer);
- ModuleBase_Tools::adjustMargins(aControlLay);
-
- QString aLabelText = QString::fromStdString(theData->widgetLabel());
- myLabel = new QLabel(aLabelText, myContainer);
- aControlLay->addWidget(myLabel);
-
- myEditor = new QLineEdit(myContainer);
- QString anObjName = QString::fromStdString(attributeID());
- myEditor->setObjectName(anObjName);
- myEditor->setReadOnly(true);
- aControlLay->addWidget(myEditor);
-
- QString aTTip = QString::fromStdString(theData->widgetTooltip());
- myEditor->setToolTip(aTTip);
- aControlLay->addWidget(myEditor);
- aControlLay->setStretch(1, 1);
-}
-
-ModuleBase_WidgetFeature::~ModuleBase_WidgetFeature()
-{
-}
-
-bool ModuleBase_WidgetFeature::setValue(ModuleBase_WidgetValue* theValue)
-{
- bool isDone = false;
-
- if (theValue) {
- ModuleBase_WidgetValueFeature* aFeatureValue =
- dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
- if (aFeatureValue)
- isDone = setObject(aFeatureValue->object());
- }
- return isDone;
-}
-
-bool ModuleBase_WidgetFeature::setObject(const ObjectPtr& theObject, bool theSendEvent)
-{
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
- std::list<ModelAPI_Validator*> aValidators;
- std::list<std::list<std::string> > anArguments;
- aFactory->validators(parentID(), attributeID(), aValidators, anArguments);
-
- // Check the type of selected object
- std::list<ModelAPI_Validator*>::iterator aValidator = aValidators.begin();
- bool isValid = true;
- for (; aValidator != aValidators.end(); aValidator++) {
- const ModelAPI_ResultValidator* aResValidator =
- dynamic_cast<const ModelAPI_ResultValidator*>(*aValidator);
- if (aResValidator) {
- isValid = false;
- if (aResValidator->isValid(theObject)) {
- isValid = true;
- break;
- }
- }
- }
- if (!isValid)
- return false;
-
- // Check the acceptability of the object as attribute
- aValidator = aValidators.begin();
- std::list<std::list<std::string> >::iterator aArgs = anArguments.begin();
- for (; aValidator != aValidators.end(); aValidator++, aArgs++) {
- const ModelAPI_RefAttrValidator* aAttrValidator =
- dynamic_cast<const ModelAPI_RefAttrValidator*>(*aValidator);
- if (aAttrValidator) {
- if (!aAttrValidator->isValid(myFeature, *aArgs, theObject)) {
- return false;
- }
- }
- }
-
- myObject = theObject;
- myEditor->setText(theObject ? theObject->data()->name().c_str() : "");
- if (theSendEvent)
- emit valuesChanged();
- return true;
-}
-
-bool ModuleBase_WidgetFeature::storeValue() const
-{
- //FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
- if (!myObject)
- return false;
-
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
- ModelAPI_AttributeRefAttr>(aData->attribute(attributeID()));
-
- ModuleBase_WidgetFeature* that = (ModuleBase_WidgetFeature*) this;
- aRef->setObject(myObject);
- myFeature->execute();
- updateObject(myFeature);
- return true;
-}
-
-bool ModuleBase_WidgetFeature::restoreValue()
-{
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
- ModelAPI_AttributeRefAttr>(aData->attribute(attributeID()));
-
- ObjectPtr anObjPtr = aRef->object();
- if (anObjPtr) {
- myObject = anObjPtr;
- myEditor->setText(myObject ? myObject->data()->name().c_str() : "");
- return true;
- }
- return false;
-}
-
-QWidget* ModuleBase_WidgetFeature::getControl() const
-{
- return myContainer;
-}
-
-QList<QWidget*> ModuleBase_WidgetFeature::getControls() const
-{
- QList<QWidget*> aList;
- aList.append(myEditor);
- return aList;
-}
+++ /dev/null
-// File: ModuleBase_WidgetFeature.h
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef ModuleBase_WidgetFeature_H
-#define ModuleBase_WidgetFeature_H
-
-#include <ModuleBase.h>
-#include "ModuleBase_ModelWidget.h"
-
-#include <QObject>
-#include <QStringList>
-
-class ModuleBase_WidgetValue;
-class ModelAPI_Feature;
-class QWidget;
-class QLabel;
-class QLineEdit;
-class QToolButton;
-
-/**\class ModuleBase_WidgetFeature
- * \ingroup GUI
- * \brief Custom widget. An abstract class to be redefined to fill with some GUI controls
- */
-class MODULEBASE_EXPORT ModuleBase_WidgetFeature : public ModuleBase_ModelWidget
-{
-Q_OBJECT
- public:
- /// Constructor
- /// \theParent the parent object
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
- ModuleBase_WidgetFeature(QWidget* theParent, const Config_WidgetAPI* theData,
- const std::string& theParentId);
- /// Destructor
- virtual ~ModuleBase_WidgetFeature();
-
- /// Set the given wrapped value to the current widget
- /// This value should be processed in the widget according to the needs
- /// \param theValue the wrapped widget value
- virtual bool setValue(ModuleBase_WidgetValue* theValue);
-
- /// Saves the internal parameters to the given feature
- /// \param theFeature a model feature to be changed
- virtual bool storeValue() const;
-
- virtual bool restoreValue();
-
- /// Returns the internal parent wiget control, that can be shown anywhere
- /// \returns the widget
- QWidget* getControl() const;
-
- /// Returns list of widget controls
- /// \return a control list
- virtual QList<QWidget*> getControls() const;
- /// Defines if it is supposed that the widget should interact with the viewer.
- virtual bool isViewerSelector() { return true; }
-
- protected:
- /// Fill the widget values by given point
- /// \param thePoint the point
- /// \return the boolean result of the feature set
- bool setObject(const ObjectPtr& theObject, bool theSendEvent = true);
-
- /// Returns current widget feature
- /// \return the feature
- const ObjectPtr object() const
- {
- return myObject;
- }
-
- /// Returns the widget editor
- /// \return the editor
- QLineEdit* editor() const
- {
- return myEditor;
- }
-
- /// Returns the possible feature kinds
- /// \return the list of kinds
- const QStringList& featureKinds() const
- {
- return myObjectKinds;
- }
-
- protected:
- ObjectPtr myObject; ///< the current widget feature
- QStringList myObjectKinds; ///< the kinds of possible features
-
- private:
- QWidget* myContainer; /// the parent top control
- QLabel* myLabel; /// the editor information label
- QLineEdit* myEditor; ///< the feature editor to visualize the feature name
-};
-
-#endif
+++ /dev/null
-// File: ModuleBase_WidgetFeatureOrAttribute.cpp
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <ModuleBase_WidgetFeatureOrAttribute.h>
-
-#include <ModuleBase_WidgetValueFeature.h>
-#include <ModuleBase_WidgetValue.h>
-
-#include <ModelAPI_RefAttrValidator.h>
-#include <ModelAPI_Session.h>
-
-#include <Config_Keywords.h>
-#include <Config_WidgetAPI.h>
-
-#include <Events_Loop.h>
-#include <ModelAPI_Events.h>
-
-#include <ModelAPI_Feature.h>
-#include <ModelAPI_Data.h>
-#include <ModelAPI_Object.h>
-#include <ModelAPI_AttributeRefAttr.h>
-#include <ModelAPI_Validator.h>
-
-#include <GeomAPI_Pnt2d.h>
-
-#include <GeomDataAPI_Point2D.h>
-
-#include <Precision.hxx>
-
-#include <QWidget>
-#include <QLineEdit>
-#include <QHBoxLayout>
-#include <QLabel>
-
-ModuleBase_WidgetFeatureOrAttribute::ModuleBase_WidgetFeatureOrAttribute(QWidget* theParent,
- const Config_WidgetAPI* theData,
- const std::string& theParentId)
- : ModuleBase_WidgetFeature(theParent, theData, theParentId)
-{
-}
-
-ModuleBase_WidgetFeatureOrAttribute::~ModuleBase_WidgetFeatureOrAttribute()
-{
-}
-
-bool ModuleBase_WidgetFeatureOrAttribute::setValue(ModuleBase_WidgetValue* theValue)
-{
- bool isDone = false;
-
- if (theValue) {
- ModuleBase_WidgetValueFeature* aFeatureValue =
- dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
- if (aFeatureValue) {
- ObjectPtr aObject = aFeatureValue->object();
-
- std::shared_ptr<ModelAPI_Attribute> anAttribute = findAttribute(aFeatureValue);
- if (anAttribute) {
- isDone = setAttribute(anAttribute, false);
- }
- else if (aObject) {
- isDone = setObject(aObject, false);
- }
-
- if (isDone)
- emit valuesChanged();
- }
- }
- return isDone;
-}
-
-bool ModuleBase_WidgetFeatureOrAttribute::storeValue() const
-{
- //FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature);
- //if (!aFeature)
- // return false;
-
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
- ModelAPI_AttributeRefAttr>(aData->attribute(attributeID()));
-
- if (myObject)
- aRef->setObject(myObject);
- if (myAttribute)
- aRef->setAttr(myAttribute);
-
- myFeature->execute();
- updateObject(myFeature);
-
- return true;
-}
-
-bool ModuleBase_WidgetFeatureOrAttribute::restoreValue()
-{
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
- ModelAPI_AttributeRefAttr>(aData->attribute(attributeID()));
-
- ObjectPtr aObj = aRef->object();
- FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object());
- if (aFeature) {
- myObject = aFeature;
- myAttribute = aRef->attr();
-
- std::string aText = "";
- if (aFeature)
- aText = aFeature->data()->name().c_str();
- if (myAttribute)
- aText = myAttribute->attributeType().c_str();
-
- editor()->setText(aText.c_str());
- return true;
- }
- return false;
-}
-
-std::shared_ptr<ModelAPI_Attribute> ModuleBase_WidgetFeatureOrAttribute::findAttribute(
- ModuleBase_WidgetValue* theValue)
-{
- std::shared_ptr<ModelAPI_Attribute> anAttribute;
- ModuleBase_WidgetValueFeature* aFeatureValue =
- dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
- if (!aFeatureValue)
- return anAttribute;
-
- std::shared_ptr<GeomAPI_Pnt2d> aValuePoint = aFeatureValue->point();
- if (aValuePoint) {
- ObjectPtr aObject = aFeatureValue->object();
- FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
- if (aFeature) {
- // find the given point in the feature attributes
- std::list<std::shared_ptr<ModelAPI_Attribute> > anAttiributes = aFeature->data()
- ->attributes(GeomDataAPI_Point2D::type());
- std::list<std::shared_ptr<ModelAPI_Attribute> >::const_iterator anIt = anAttiributes
- .begin(), aLast = anAttiributes.end();
- for (; anIt != aLast && !anAttribute; anIt++) {
- std::shared_ptr<GeomDataAPI_Point2D> aCurPoint = std::dynamic_pointer_cast<
- GeomDataAPI_Point2D>(*anIt);
- if (aCurPoint && aCurPoint->pnt()->distance(aValuePoint) < Precision::Confusion())
- anAttribute = aCurPoint;
- }
- }
- }
- return anAttribute;
-}
-
-bool ModuleBase_WidgetFeatureOrAttribute::setAttribute(
- const std::shared_ptr<ModelAPI_Attribute>& theAttribute, bool theSendEvent)
-{
- if (!theAttribute) // || !featureKinds().contains(theAttribute->attributeType().c_str()))
- return false;
-
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
- std::list<ModelAPI_Validator*> aValidators;
- std::list<std::list<std::string> > anArguments;
- aFactory->validators(parentID(), attributeID(), aValidators, anArguments);
-
- // Check the acceptability of the attribute
- std::list<ModelAPI_Validator*>::iterator aValidator = aValidators.begin();
- int aSize = aValidators.size();
- std::list<std::list<std::string> >::iterator aArgs = anArguments.begin();
- for (; aValidator != aValidators.end(); aValidator++, aArgs++) {
- const ModelAPI_RefAttrValidator* aAttrValidator =
- dynamic_cast<const ModelAPI_RefAttrValidator*>(*aValidator);
- if (aAttrValidator) {
- if (!aAttrValidator->isValid(myFeature, *aArgs, theAttribute)) {
- return false;
- }
- }
- }
-
- myAttribute = theAttribute;
- editor()->setText(theAttribute ? theAttribute->attributeType().c_str() : "");
- if (theSendEvent)
- emit valuesChanged();
- return true;
-}
-
+++ /dev/null
-// File: ModuleBase_WidgetFeatureOrAttribute.h
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef ModuleBase_WidgetFeatureOrAttribute_H
-#define ModuleBase_WidgetFeatureOrAttribute_H
-
-#include <ModuleBase.h>
-#include "ModuleBase_WidgetFeature.h"
-
-#include <QObject>
-
-class ModuleBase_WidgetValue;
-class ModelAPI_Attribute;
-
-/**\class ModuleBase_WidgetFeatureOrAttribute
- * \ingroup GUI
- * \brief Custom widget. An abstract class to be redefined to fill with some GUI controls
- */
-class MODULEBASE_EXPORT ModuleBase_WidgetFeatureOrAttribute : public ModuleBase_WidgetFeature
-{
-Q_OBJECT
- public:
- /// Constructor
- /// \theParent the parent object
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
- ModuleBase_WidgetFeatureOrAttribute(QWidget* theParent, const Config_WidgetAPI* theData,
- const std::string& theParentId);
- /// Destructor
- virtual ~ModuleBase_WidgetFeatureOrAttribute();
-
- /// Set the given wrapped value to the current widget
- /// This value should be processed in the widget according to the needs
- /// \param theValue the wrapped widget value
- virtual bool setValue(ModuleBase_WidgetValue* theValue);
-
- /// Saves the internal parameters to the given feature
- /// \param theFeature a model feature to be changed
- virtual bool storeValue() const;
-
- virtual bool restoreValue();
- /// Defines if it is supposed that the widget should interact with the viewer.
- virtual bool isViewerSelector() { return true; }
-
- protected:
- /// Returns the feature attribute if it can be found by the given value
- /// \param theValue the widget value
- /// \return an attribute or null
- std::shared_ptr<ModelAPI_Attribute> findAttribute(ModuleBase_WidgetValue* theValue);
-
- /// Set the attribute
- /// \param theAttribute value
- /// \return the boolean result of the attribute set
- bool setAttribute(const std::shared_ptr<ModelAPI_Attribute>& theAttribute, bool theSendEvent =
- true);
-
- protected:
- std::shared_ptr<ModelAPI_Attribute> myAttribute; /// < the attribute
-};
-
-#endif
void ModuleBase_WidgetMultiSelector::onSelectionTypeChanged()
{
activateShapeSelection();
- QList<ObjectPtr> anEmptyList;
+ QObjectPtrList anEmptyList;
myWorkshop->setSelected(anEmptyList);
// Clear mySelection, myListControl and storeValue()
onSelectionChanged();
+++ /dev/null
-// File: ModuleBase_WidgetPoint2D.cpp
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <ModuleBase_WidgetPoint2D.h>
-#include <ModuleBase_WidgetValueFeature.h>
-#include <ModuleBase_DoubleSpinBox.h>
-#include <ModuleBase_Tools.h>
-
-#include <Config_Keywords.h>
-#include <Config_WidgetAPI.h>
-
-#include <Events_Loop.h>
-#include <ModelAPI_Events.h>
-
-#include <ModelAPI_Feature.h>
-#include <ModelAPI_Data.h>
-#include <ModelAPI_Object.h>
-#include <GeomDataAPI_Point2D.h>
-#include <GeomAPI_Pnt2d.h>
-
-#include <QGroupBox>
-#include <QGridLayout>
-#include <QLabel>
-#include <QEvent>
-
-#include <cfloat>
-#include <climits>
-
-ModuleBase_WidgetPoint2D::ModuleBase_WidgetPoint2D(QWidget* theParent,
- const Config_WidgetAPI* theData,
- const std::string& theParentId)
- : ModuleBase_ModelWidget(theParent, theData, theParentId)
-{
- myOptionParam = theData->getProperty(PREVIOUS_FEATURE_PARAM);
- QString aPageName = QString::fromStdString(theData->getProperty(CONTAINER_PAGE_NAME));
- myGroupBox = new QGroupBox(aPageName, theParent);
- myGroupBox->setFlat(false);
-
- QGridLayout* aGroupLay = new QGridLayout(myGroupBox);
- ModuleBase_Tools::adjustMargins(aGroupLay);
- aGroupLay->setColumnStretch(1, 1);
- {
- QLabel* aLabel = new QLabel(myGroupBox);
- aLabel->setText("X");
- aLabel->setPixmap(QPixmap(":pictures/x_point.png"));
- aGroupLay->addWidget(aLabel, 0, 0);
-
- myXSpin = new ModuleBase_DoubleSpinBox(myGroupBox);
- myXSpin->setMinimum(-DBL_MAX);
- myXSpin->setMaximum(DBL_MAX);
- myXSpin->setToolTip("X");
- aGroupLay->addWidget(myXSpin, 0, 1);
-
- connect(myXSpin, SIGNAL(valueChanged(double)), this, SIGNAL(valuesChanged()));
- }
- {
- QLabel* aLabel = new QLabel(myGroupBox);
- aLabel->setText("Y");
- aLabel->setPixmap(QPixmap(":pictures/y_point.png"));
- aGroupLay->addWidget(aLabel, 1, 0);
-
- myYSpin = new ModuleBase_DoubleSpinBox(myGroupBox);
- myYSpin->setMinimum(-DBL_MAX);
- myYSpin->setMaximum(DBL_MAX);
- myYSpin->setToolTip("X");
- aGroupLay->addWidget(myYSpin, 1, 1);
-
- connect(myYSpin, SIGNAL(valueChanged(double)), this, SIGNAL(valuesChanged()));
- }
-}
-
-ModuleBase_WidgetPoint2D::~ModuleBase_WidgetPoint2D()
-{
-}
-
-bool ModuleBase_WidgetPoint2D::setValue(ModuleBase_WidgetValue* theValue)
-{
- bool isDone = false;
- if (theValue) {
- ModuleBase_WidgetValueFeature* aFeatureValue =
- dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
- if (aFeatureValue) {
- std::shared_ptr<GeomAPI_Pnt2d> aPoint = aFeatureValue->point();
- if (aPoint) {
- setPoint(aPoint);
- isDone = true;
- }
- }
- }
- return isDone;
-}
-
-void ModuleBase_WidgetPoint2D::setPoint(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
-{
-
- bool isBlocked = this->blockSignals(true);
- myXSpin->setValue(thePoint->x());
- myYSpin->setValue(thePoint->y());
- this->blockSignals(isBlocked);
-
- emit valuesChanged();
-}
-
-bool ModuleBase_WidgetPoint2D::storeValue() const
-{
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(attributeID()));
-
- ModuleBase_WidgetPoint2D* that = (ModuleBase_WidgetPoint2D*) this;
- bool isBlocked = that->blockSignals(true);
- bool isImmutable = aPoint->setImmutable(true);
-#ifdef _DEBUG
- std::string _attr_name = myAttributeID;
- double _X = myXSpin->value();
- double _Y = myYSpin->value();
-#endif
- aPoint->setValue(myXSpin->value(), myYSpin->value());
- updateObject(myFeature);
- aPoint->setImmutable(isImmutable);
- that->blockSignals(isBlocked);
-
- return true;
-}
-
-bool ModuleBase_WidgetPoint2D::restoreValue()
-{
- std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
- std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(attributeID()));
-
-#ifdef _DEBUG
- std::string _attr_name = myAttributeID;
- double _X = aPoint->x();
- double _Y = aPoint->y();
-#endif
- bool isBlocked = this->blockSignals(true);
- myXSpin->setValue(aPoint->x());
- myYSpin->setValue(aPoint->y());
- this->blockSignals(isBlocked);
- return true;
-}
-
-QWidget* ModuleBase_WidgetPoint2D::getControl() const
-{
- return myGroupBox;
-}
-
-QList<QWidget*> ModuleBase_WidgetPoint2D::getControls() const
-{
- QList<QWidget*> aControls;
- aControls.push_back(myXSpin);
- aControls.push_back(myYSpin);
-
- return aControls;
-}
-
-bool ModuleBase_WidgetPoint2D::initFromPrevious(ObjectPtr theObject)
-{
- if (myOptionParam.length() == 0)
- return false;
- std::shared_ptr<ModelAPI_Data> aData = theObject->data();
- std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(myOptionParam));
- if (aPoint) {
- bool isBlocked = this->blockSignals(true);
- myXSpin->setValue(aPoint->x());
- myYSpin->setValue(aPoint->y());
- this->blockSignals(isBlocked);
-
- emit valuesChanged();
- emit storedPoint2D(theObject, myOptionParam);
- return true;
- }
- return false;
-}
+++ /dev/null
-// File: ModuleBase_WidgetPoint2D.h
-// Created: 25 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef ModuleBase_WidgetPoint2D_H
-#define ModuleBase_WidgetPoint2D_H
-
-#include <ModuleBase.h>
-#include "ModuleBase_ModelWidget.h"
-
-#include <QObject>
-
-class ModelAPI_Feature;
-class ModuleBase_WidgetValue;
-class GeomAPI_Pnt2d;
-
-class QGroupBox;
-class ModuleBase_DoubleSpinBox;
-
-/**\class ModuleBase_WidgetPoint2D
- * \ingroup GUI
- * \brief Custom widget. An abstract class to be redefined to fill with some GUI controls
- */
-class MODULEBASE_EXPORT ModuleBase_WidgetPoint2D : public ModuleBase_ModelWidget
-{
-Q_OBJECT
- public:
- /// Constructor
- /// \theParent the parent object
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
- ModuleBase_WidgetPoint2D(QWidget* theParent, const Config_WidgetAPI* theData,
- const std::string& theParentId);
- /// Destructor
- virtual ~ModuleBase_WidgetPoint2D();
-
- /// Set the given wrapped value to the current widget
- /// This value should be processed in the widget according to the needs
- /// \param theValue the wrapped widget value
- virtual bool setValue(ModuleBase_WidgetValue* theValue);
-
- /// Saves the internal parameters to the given feature
- /// \param theObject a model feature to be changed
- virtual bool storeValue() const;
-
- virtual bool restoreValue();
-
- /// Returns the internal parent wiget control, that can be shown anywhere
- /// \returns the widget
- QWidget* getControl() const;
-
- /// Returns list of widget controls
- /// \return a control list
- virtual QList<QWidget*> getControls() const;
-
- bool initFromPrevious(ObjectPtr theObject);
-
-signals:
- /// Signal about the point 2d set to the feature
- /// \param the feature
- /// \param the attribute of the feature
- void storedPoint2D(ObjectPtr theObject, const std::string& theAttribute);
-
- protected:
- /// Fill the widget values by given point
- /// \param thePoint the point
- void setPoint(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint);
-
- private:
- QGroupBox* myGroupBox; ///< the parent group box for all intenal widgets
- ModuleBase_DoubleSpinBox* myXSpin; ///< the spin box for the X coordinate
- ModuleBase_DoubleSpinBox* myYSpin; ///< the spin box for the Y coordinate
-
- std::string myOptionParam; /// Parameter name which has to be taken from previous feature
-};
-
-#endif
+++ /dev/null
-// File: ModuleBase_WidgetPoint2dDistance.h
-// Created: 23 June 2014
-// Author: Vitaly Smetannikov
-
-#include <ModuleBase_WidgetPoint2dDistance.h>
-#include <ModuleBase_WidgetValueFeature.h>
-#include <ModuleBase_DoubleSpinBox.h>
-
-#include <GeomAPI_Pnt2d.h>
-#include <Config_WidgetAPI.h>
-#include <GeomDataAPI_Point2D.h>
-
-#include <ModelAPI_Data.h>
-#include <ModelAPI_AttributeDouble.h>
-
-ModuleBase_WidgetPoint2dDistance::ModuleBase_WidgetPoint2dDistance(QWidget* theParent,
- const Config_WidgetAPI* theData,
- const std::string& theParentId)
- : ModuleBase_WidgetDoubleValue(theParent, theData, theParentId)
-{
- myFirstPntName = theData->getProperty("first_point");
-}
-
-ModuleBase_WidgetPoint2dDistance::~ModuleBase_WidgetPoint2dDistance()
-{
-}
-
-bool ModuleBase_WidgetPoint2dDistance::setValue(ModuleBase_WidgetValue* theValue)
-{
- bool isDone = false;
-
- if (theValue) {
- ModuleBase_WidgetValueFeature* aFeatureValue =
- dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
- if (aFeatureValue) {
- std::shared_ptr<GeomAPI_Pnt2d> aPnt = aFeatureValue->point();
- ObjectPtr aObject = aFeatureValue->object();
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
- if (aFeature && aPnt) {
- setPoint(aFeature, aPnt);
- isDone = true;
- }
- }
- }
- return isDone;
-}
-
-void ModuleBase_WidgetPoint2dDistance::setPoint(FeaturePtr theFeature,
- const std::shared_ptr<GeomAPI_Pnt2d>& thePnt)
-{
- std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
- std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(myFirstPntName));
- if (!aPoint)
- return;
-
- double aRadius = thePnt->distance(aPoint->pnt());
- AttributeDoublePtr aReal = aData->real(attributeID());
- if (aReal && (aReal->value() != aRadius)) {
- aReal->setValue(aRadius);
- mySpinBox->setValue(aRadius);
- }
-}
+++ /dev/null
-// File: ModuleBase_WidgetPoint2dDistance.h
-// Created: 23 June 2014
-// Author: Vitaly Smetannikov
-
-#ifndef ModuleBase_WidgetPoint2dDistance_H
-#define ModuleBase_WidgetPoint2dDistance_H
-
-#include "ModuleBase.h"
-#include "ModuleBase_WidgetDoubleValue.h"
-
-class ModuleBase_WidgetValue;
-class GeomAPI_Pnt2d;
-
-class MODULEBASE_EXPORT ModuleBase_WidgetPoint2dDistance : public ModuleBase_WidgetDoubleValue
-{
-Q_OBJECT
- public:
- /// Constructor
- /// \theParent the parent object
- /// \theData the widget configuation. The attribute of the model widget is obtained from
- ModuleBase_WidgetPoint2dDistance(QWidget* theParent, const Config_WidgetAPI* theData,
- const std::string& theParentId);
-
- virtual ~ModuleBase_WidgetPoint2dDistance();
-
- /// Set the given wrapped value to the current widget
- /// This value should be processed in the widget according to the needs
- /// \param theValue the wrapped widget value
- virtual bool setValue(ModuleBase_WidgetValue* theValue);
-
- protected:
- /// Set the second point which defines a value in the widget as a distance with a first point defined by feature
- void setPoint(FeaturePtr theFeature, const std::shared_ptr<GeomAPI_Pnt2d>& thePnt);
-
- private:
- std::string myFirstPntName;
-};
-
-#endif
#include <Events_Message.h>
#include <GeomAPI_Interface.h>
#include <GeomAPI_Shape.h>
+
#include <ModelAPI_AttributeReference.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Tools.h>
#include <ModelAPI_ResultBody.h>
+#include <ModelAPI_AttributeRefAttr.h>
+
#include <Config_WidgetAPI.h>
#include <Events_Error.h>
DataPtr aData = myFeature->data();
if (myUseSubShapes) {
- std::shared_ptr<ModelAPI_AttributeSelection> aSelect =
- std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(aData->attribute(attributeID()));
-
ResultPtr aBody = std::dynamic_pointer_cast<ModelAPI_Result>(mySelectedObject);
if (aBody) {
- aSelect->setValue(aBody, myShape);
+ AttributePtr aAttr = aData->attribute(attributeID());
+ std::shared_ptr<ModelAPI_AttributeSelection> aSelectAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(aAttr);
+
+ if (aSelectAttr)
+ aSelectAttr->setValue(aBody, myShape);
updateObject(myFeature);
return true;
}
} else {
- std::shared_ptr<ModelAPI_AttributeReference> aRef =
- std::dynamic_pointer_cast<ModelAPI_AttributeReference>(aData->attribute(attributeID()));
-
- ObjectPtr aObject = aRef->value();
- if (!(aObject && aObject->isSame(mySelectedObject))) {
- aRef->setValue(mySelectedObject);
- updateObject(myFeature);
- return true;
+ AttributeReferencePtr aRef = aData->reference(attributeID());
+ if (aRef) {
+ ObjectPtr aObject = aRef->value();
+ if (!(aObject && aObject->isSame(mySelectedObject))) {
+ aRef->setValue(mySelectedObject);
+ updateObject(myFeature);
+ return true;
+ }
+ } else {
+ AttributeRefAttrPtr aRefAttr = aData->refattr(attributeID());
+ if (aRefAttr) {
+ ObjectPtr aObject = aRefAttr->object();
+ if (!(aObject && aObject->isSame(mySelectedObject))) {
+ aRefAttr->setObject(mySelectedObject);
+ updateObject(myFeature);
+ return true;
+ }
+ }
}
}
return false;
myShape = aSelect->value();
}
} else {
- std::shared_ptr<ModelAPI_AttributeReference> aRef = aData->reference(attributeID());
- mySelectedObject = aRef->value();
+ AttributeReferencePtr aRef = aData->reference(attributeID());
+ if (aRef)
+ mySelectedObject = aRef->value();
+ else {
+ AttributeRefAttrPtr aRefAttr = aData->refattr(attributeID());
+ if (aRefAttr)
+ mySelectedObject = aRefAttr->object();
+ }
}
updateSelectionName();
//********************************************************************
void ModuleBase_WidgetShapeSelector::onSelectionChanged()
{
- QList<ObjectPtr> aObjects = myWorkshop->selection()->selectedObjects();
+ QObjectPtrList aObjects = myWorkshop->selection()->selectedPresentations();
if (aObjects.size() > 0) {
ObjectPtr aObject = aObjects.first();
if ((!mySelectedObject) && (!aObject))
myShape = theShape;
if (mySelectedObject) {
raisePanel();
- if (!myUseSubShapes) {
- static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_TOHIDE);
- ModelAPI_EventCreator::get()->sendUpdated(mySelectedObject, anEvent);
- }
}
updateSelectionName();
//activateSelection(false);
}
}
-//********************************************************************
-bool ModuleBase_WidgetShapeSelector::focusTo()
-{
- //activateSelection(true);
- return ModuleBase_ModelWidget::focusTo();
-}
-
-//********************************************************************
-bool ModuleBase_WidgetShapeSelector::eventFilter(QObject* theObj, QEvent* theEvent)
-{
- //if (theObj == myTextLine) {
- // if (theEvent->type() == QEvent::FocusIn)
- // activateSelection(true);
- //}
- return ModuleBase_ModelWidget::eventFilter(theObj, theEvent);
-}
-
//********************************************************************
bool ModuleBase_WidgetShapeSelector::setValue(ModuleBase_WidgetValue* theValue)
{
virtual bool restoreValue();
- virtual bool focusTo();
-
/// Returns the internal parent wiget control, that can be shown anywhere
/// \returns the widget
QWidget* getControl() const
void onSelectionChanged();
protected:
- bool eventFilter(QObject* theObj, QEvent* theEvent);
-
void updateSelectionName();
void raisePanel() const;
OCCViewer_Viewer* aViewer = mySelector->viewer();
SUIT_ViewManager* aMgr = aViewer->getViewManager();
- connect(aMgr, SIGNAL(lastViewClosed(SUIT_ViewManager*)), this, SIGNAL(lastViewClosed()));
- connect(aMgr, SIGNAL(tryCloseView(SUIT_ViewManager*)), this, SIGNAL(tryCloseView()));
- connect(aMgr, SIGNAL(deleteView(SUIT_ViewManager*)), this, SIGNAL(deleteView()));
- connect(aMgr, SIGNAL(viewCreated(SUIT_ViewManager*)), this, SIGNAL(viewCreated()));
- connect(aMgr, SIGNAL(activated(SUIT_ViewManager*)), this, SIGNAL(activated()));
-
- connect(aMgr, SIGNAL(mousePress(SUIT_ViewWindow*, QMouseEvent*)), this,
- SLOT(onMousePress(SUIT_ViewWindow*, QMouseEvent*)));
- connect(aMgr, SIGNAL(mouseRelease(SUIT_ViewWindow*, QMouseEvent*)), this,
- SLOT(onMouseRelease(SUIT_ViewWindow*, QMouseEvent*)));
- connect(aMgr, SIGNAL(mouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*)), this,
- SLOT(onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*)));
- connect(aMgr, SIGNAL(mouseMove(SUIT_ViewWindow*, QMouseEvent*)), this,
- SLOT(onMouseMove(SUIT_ViewWindow*, QMouseEvent*)));
- connect(aMgr, SIGNAL(keyPress(SUIT_ViewWindow*, QKeyEvent*)), this,
- SLOT(onKeyPress(SUIT_ViewWindow*, QKeyEvent*)));
- connect(aMgr, SIGNAL(keyRelease(SUIT_ViewWindow*, QKeyEvent*)), this,
- SLOT(onKeyRelease(SUIT_ViewWindow*, QKeyEvent*)));
-
- connect(aViewer, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onMousePress(SUIT_ViewWindow*, QMouseEvent* theEvent)
-{
- emit mousePress(theEvent);
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onMouseRelease(SUIT_ViewWindow*, QMouseEvent* theEvent)
-{
- emit mouseRelease(theEvent);
- //if ((theEvent->button() == Qt::RightButton) &&
- // (theEvent->modifiers() == Qt::NoModifier)) {
- // QContextMenuEvent aEvent(QContextMenuEvent::Mouse, theEvent->pos(), theEvent->globalPos());
- // emit contextMenuRequested(&aEvent);
- //}
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent* theEvent)
-{
- emit mouseDoubleClick(theEvent);
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onMouseMove(SUIT_ViewWindow*, QMouseEvent* theEvent)
-{
- emit mouseMove(theEvent);
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onKeyPress(SUIT_ViewWindow*, QKeyEvent* theEvent)
-{
- emit keyPress(theEvent);
-}
-
-//**********************************************
-void NewGeom_SalomeViewer::onKeyRelease(SUIT_ViewWindow*, QKeyEvent* theEvent)
-{
- emit keyRelease(theEvent);
-}
+ // TODO: Provide ModuleBase_IViewWindow interface
+ //connect(aMgr, SIGNAL(lastViewClosed(SUIT_ViewManager*)), this, SIGNAL(lastViewClosed()));
+ //connect(aMgr, SIGNAL(tryCloseView(SUIT_ViewManager*)), this, SIGNAL(tryCloseView()));
+ //connect(aMgr, SIGNAL(deleteView(SUIT_ViewManager*)), this, SIGNAL(deleteView()));
+ //connect(aMgr, SIGNAL(viewCreated(SUIT_ViewManager*)), this, SIGNAL(viewCreated()));
+ //connect(aMgr, SIGNAL(activated(SUIT_ViewManager*)), this, SIGNAL(activated()));
+
+ //connect(aMgr, SIGNAL(mousePress(SUIT_ViewWindow*, QMouseEvent*)), this,
+ // SLOT(onMousePress(SUIT_ViewWindow*, QMouseEvent*)));
+ //connect(aMgr, SIGNAL(mouseRelease(SUIT_ViewWindow*, QMouseEvent*)), this,
+ // SLOT(onMouseRelease(SUIT_ViewWindow*, QMouseEvent*)));
+ //connect(aMgr, SIGNAL(mouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*)), this,
+ // SLOT(onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*)));
+ //connect(aMgr, SIGNAL(mouseMove(SUIT_ViewWindow*, QMouseEvent*)), this,
+ // SLOT(onMouseMove(SUIT_ViewWindow*, QMouseEvent*)));
+ //connect(aMgr, SIGNAL(keyPress(SUIT_ViewWindow*, QKeyEvent*)), this,
+ // SLOT(onKeyPress(SUIT_ViewWindow*, QKeyEvent*)));
+ //connect(aMgr, SIGNAL(keyRelease(SUIT_ViewWindow*, QKeyEvent*)), this,
+ // SLOT(onKeyRelease(SUIT_ViewWindow*, QKeyEvent*)));
+
+ //connect(aViewer, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
+}
+
+//**********************************************
+//void NewGeom_SalomeViewer::onMousePress(SUIT_ViewWindow*, QMouseEvent* theEvent)
+//{
+// emit mousePress(theEvent);
+//}
+//
+////**********************************************
+//void NewGeom_SalomeViewer::onMouseRelease(SUIT_ViewWindow*, QMouseEvent* theEvent)
+//{
+// emit mouseRelease(theEvent);
+//}
+//
+////**********************************************
+//void NewGeom_SalomeViewer::onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent* theEvent)
+//{
+// emit mouseDoubleClick(theEvent);
+//}
+//
+////**********************************************
+//void NewGeom_SalomeViewer::onMouseMove(SUIT_ViewWindow*, QMouseEvent* theEvent)
+//{
+// emit mouseMove(theEvent);
+//}
+//
+////**********************************************
+//void NewGeom_SalomeViewer::onKeyPress(SUIT_ViewWindow*, QKeyEvent* theEvent)
+//{
+// emit keyPress(theEvent);
+//}
+//
+////**********************************************
+//void NewGeom_SalomeViewer::onKeyRelease(SUIT_ViewWindow*, QKeyEvent* theEvent)
+//{
+// emit keyRelease(theEvent);
+//}
//**********************************************
void NewGeom_SalomeViewer::enableSelection(bool isEnabled)
}
private slots:
- void onMousePress(SUIT_ViewWindow*, QMouseEvent*);
- void onMouseRelease(SUIT_ViewWindow*, QMouseEvent*);
- void onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*);
- void onMouseMove(SUIT_ViewWindow*, QMouseEvent*);
- void onKeyPress(SUIT_ViewWindow*, QKeyEvent*);
- void onKeyRelease(SUIT_ViewWindow*, QKeyEvent*);
+ // TODO: Provide ModuleBase_IViewWindow interface
+ //void onMousePress(SUIT_ViewWindow*, QMouseEvent*);
+ //void onMouseRelease(SUIT_ViewWindow*, QMouseEvent*);
+ //void onMouseDoubleClick(SUIT_ViewWindow*, QMouseEvent*);
+ //void onMouseMove(SUIT_ViewWindow*, QMouseEvent*);
+ //void onKeyPress(SUIT_ViewWindow*, QKeyEvent*);
+ //void onKeyRelease(SUIT_ViewWindow*, QKeyEvent*);
private:
NewGeom_OCCSelector* mySelector;
PartSet.h
PartSet_Constants.h
PartSet_EditLine.h
- PartSet_Listener.h
+# PartSet_Listener.h
PartSet_Module.h
- PartSet_OperationFeatureCreate.h
- PartSet_OperationFeatureEdit.h
- PartSet_OperationSketchBase.h
- PartSet_OperationSketch.h
- PartSet_OperationFeatureBase.h
+# PartSet_OperationFeatureCreate.h
+# PartSet_OperationFeatureEdit.h
+# PartSet_OperationSketchBase.h
+# PartSet_OperationSketch.h
+# PartSet_OperationFeatureBase.h
PartSet_Tools.h
PartSet_WidgetSketchLabel.h
PartSet_Validators.h
+ PartSet_WidgetPoint2d.h
+ PartSet_WidgetPoint2dDistance.h
+# PartSet_Operation.h
)
SET(PROJECT_SOURCES
PartSet_EditLine.cpp
- PartSet_Listener.cpp
+# PartSet_Listener.cpp
PartSet_Module.cpp
- PartSet_OperationFeatureCreate.cpp
- PartSet_OperationFeatureEdit.cpp
- PartSet_OperationSketchBase.cpp
- PartSet_OperationSketch.cpp
- PartSet_OperationFeatureBase.cpp
+# PartSet_OperationFeatureCreate.cpp
+# PartSet_OperationFeatureEdit.cpp
+# PartSet_OperationSketchBase.cpp
+# PartSet_OperationSketch.cpp
+# PartSet_OperationFeatureBase.cpp
PartSet_Tools.cpp
PartSet_WidgetSketchLabel.cpp
PartSet_Validators.cpp
+ PartSet_WidgetPoint2d.cpp
+ PartSet_WidgetPoint2dDistance.cpp
+# PartSet_Operation.cpp
)
SET(PROJECT_RESOURCES
+++ /dev/null
-// File: PartSet_Listener.h
-// Created: 28 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_Listener.h>
-
-#include <PartSet_Module.h>
-#include <PartSet_OperationSketchBase.h>
-#include <PartSet_OperationSketch.h>
-#include <PartSet_OperationFeatureCreate.h>
-
-#include <XGUI_Displayer.h>
-#include <XGUI_Workshop.h>
-#include <XGUI_OperationMgr.h>
-
-#include <ModuleBase_Operation.h>
-
-#include <Events_Loop.h>
-#include <ModelAPI_Events.h>
-#include <ModelAPI_Feature.h>
-
-#ifdef _DEBUG
-#include <QDebug>
-#endif
-
-using namespace std;
-
-PartSet_Listener::PartSet_Listener(PartSet_Module* theModule)
- : myModule(theModule)
-{
- Events_Loop* aLoop = Events_Loop::loop();
- aLoop->registerListener(this, aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY));
- aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED));
- aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED));
-}
-
-PartSet_Listener::~PartSet_Listener()
-{
-}
-
-//******************************************************
-void PartSet_Listener::processEvent(const std::shared_ptr<Events_Message>& theMessage)
-{
- ModuleBase_Operation* anOperation = myModule->xWorkshop()->operationMgr()->currentOperation();
- PartSet_OperationSketchBase* aSketchOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
- if (!aSketchOp)
- return;
-
- XGUI_Displayer* aDisplayer = myModule->xWorkshop()->displayer();
- QString aType = QString(theMessage->eventID().eventText());
- if (aType == EVENT_OBJECT_CREATED) {
- std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
- std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
- std::set<ObjectPtr> aFeatures = aUpdMsg->objects();
-
- PartSet_OperationSketch* aSketchOp =
- dynamic_cast<PartSet_OperationSketch*>(myModule->xWorkshop()->operationMgr()->currentOperation());
-
- std::set<ObjectPtr>::const_iterator anIt = aFeatures.begin(), aLast = aFeatures.end();
- for (; anIt != aLast; anIt++) {
- ObjectPtr aObj = (*anIt);
- // If current operation is Sketch then there is no active sketching operation
- // and possible the object was created by Redo operation
- if (aSketchOp) {
- XGUI_Displayer* aDisplayer = myModule->xWorkshop()->displayer();
- // Very possible it is not displayed
- aDisplayer->display(aObj, false);
- }
- }
- } else if (aType == EVENT_OBJECT_TO_REDISPLAY) {
- PartSet_OperationFeatureCreate* aCreationOp =
- dynamic_cast<PartSet_OperationFeatureCreate*>
- (myModule->xWorkshop()->operationMgr()->currentOperation());
- if (aCreationOp) {
- // Deactivate currently creating objects for selection
- XGUI_Displayer* aDisplayer = myModule->xWorkshop()->displayer();
- FeaturePtr aFeature = aCreationOp->feature();
- const std::list<ResultPtr>& aResults = aFeature->results();
- std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
- std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
-
- std::set<ObjectPtr> aFeatures = aUpdMsg->objects();
- std::set<ObjectPtr>::const_iterator aObjIt, aNoObj = aFeatures.cend();
- std::list<ResultPtr>::const_iterator anIt = aResults.begin(), aLast = aResults.end();
- for (; anIt != aLast; anIt++) {
- aObjIt = aFeatures.find(*anIt);
- if (aObjIt != aNoObj) {
- aDisplayer->deactivate(*aObjIt);
- }
- }
- }
- } else if (aType == EVENT_OBJECT_DELETED) {
- std::shared_ptr<ModelAPI_ObjectDeletedMessage> aDelMsg =
- std::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
- std::shared_ptr<ModelAPI_Document> aDoc = aDelMsg->document();
-
- std::set<std::string> aGroups = aDelMsg->groups();
- std::set<std::string>::const_iterator anIt = aGroups.begin(), aLast = aGroups.end();
- for (; anIt != aLast; anIt++) {
- std::string aGroup = *anIt;
- if (aGroup.compare(SketchPlugin_Sketch::ID()) == 0) { // Update only Sketch group
- myModule->xWorkshop()->displayer()->eraseDeletedResults();
- myModule->updateCurrentPreview(aGroup);
- }
- }
- }
-}
+++ /dev/null
-// File: PartSet_Listener.h
-// Created: 28 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_Listener_H
-#define PartSet_Listener_H
-
-#include "PartSet.h"
-
-#include <Events_Listener.h>
-
-class PartSet_Module;
-
-/*!
- \class PartSet_Listener
- * \brief The operation for the sketch feature creation
- */
-class PARTSET_EXPORT PartSet_Listener : public Events_Listener
-{
- public:
- /// Constructor
- /// \param theId the feature identifier
- /// \param theParent the operation parent
- PartSet_Listener(PartSet_Module* theModule);
- /// Destructor
- virtual ~PartSet_Listener();
-
- /// This method is called by loop when the event is started to process.
- virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
-
- private:
- PartSet_Module* myModule; ///< the current module
-};
-
-#endif
-#include <PartSet_Module.h>
-#include <PartSet_OperationSketch.h>
-#include <PartSet_OperationFeatureCreate.h>
-#include <PartSet_OperationFeatureEdit.h>
-#include <PartSet_Listener.h>
-#include <PartSet_TestOCC.h>
-#include <PartSet_WidgetSketchLabel.h>
-#include <PartSet_Validators.h>
-#include <PartSet_Tools.h>
+#include "PartSet_Module.h"
+//#include <PartSet_OperationSketch.h>
+//#include <PartSet_OperationFeatureCreate.h>
+//#include <PartSet_OperationFeatureEdit.h>
+//#include <PartSet_Listener.h>
+//#include <PartSet_TestOCC.h>
+#include "PartSet_WidgetSketchLabel.h"
+#include "PartSet_Validators.h"
+#include "PartSet_Tools.h"
+#include "PartSet_WidgetPoint2D.h"
+#include "PartSet_WidgetPoint2dDistance.h"
+//#include "PartSet_Operation.h"
#include <ModuleBase_Operation.h>
-#include <ModuleBase_OperationDescription.h>
-#include <ModuleBase_WidgetFactory.h>
-#include <ModuleBase_Operation.h>
+#include <ModuleBase_IViewer.h>
+#include <ModuleBase_IViewWindow.h>
+#include <ModuleBase_IPropertyPanel.h>
+//#include <ModuleBase_OperationDescription.h>
+//#include <ModuleBase_WidgetFactory.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_Events.h>
#include <SketchPlugin_Line.h>
#include <SketchPlugin_Sketch.h>
-
-#include <Config_PointerMessage.h>
-#include <Config_ModuleReader.h>
-#include <Config_WidgetReader.h>
-#include <Events_Loop.h>
+#include <SketchPlugin_Point.h>
+#include <SketchPlugin_Arc.h>
+#include <SketchPlugin_Circle.h>
+
+//#include <Config_PointerMessage.h>
+//#include <Config_ModuleReader.h>
+//#include <Config_WidgetReader.h>
+//#include <Events_Loop.h>
//#include <Events_Message.h>
//#include <Events_Error.h>
-#include <GeomAPI_Shape.h>
-#include <GeomAPI_AISObject.h>
-#include <AIS_Shape.hxx>
-#include <AIS_DimensionSelectionMode.hxx>
+//#include <GeomAPI_Shape.h>
+//#include <GeomAPI_AISObject.h>
+
//#include <AIS_Shape.hxx>
+
//#include <AIS_DimensionSelectionMode.hxx>
#include <StdSelect_TypeOfFace.hxx>
#include <QObject>
#include <QMouseEvent>
#include <QString>
+#include <QTimer>
#include <GeomAlgoAPI_FaceBuilder.h>
#include <GeomDataAPI_Dir.h>
#include <QDebug>
#endif
+
/*!Create and return new instance of XGUI_Module*/
extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop* theWshop)
{
}
PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop)
- : ModuleBase_IModule(theWshop)
+ : ModuleBase_IModule(theWshop),
+ myIsDragging(false), myRestartingMode(true), myDragDone(false)
{
- //myWorkshop = theWshop;
- myListener = new PartSet_Listener(this);
+ //myWorkshop = dynamic_cast<XGUI_Workshop*>(theWshop);
+ ModuleBase_IViewer* aViewer = aViewer = theWshop->viewer();
+ connect(aViewer, SIGNAL(mousePress(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMousePressed(ModuleBase_IViewWindow*, QMouseEvent*)));
+
+ connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseReleased(ModuleBase_IViewWindow*, QMouseEvent*)));
+
+ connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMoved(ModuleBase_IViewWindow*, QMouseEvent*)));
- connect(myWorkshop, SIGNAL(operationStarted(ModuleBase_Operation*)),
- this, SLOT(onOperationStarted(ModuleBase_Operation*)));
+ //myListener = new PartSet_Listener(this);
- connect(myWorkshop, SIGNAL(operationStopped(ModuleBase_Operation*)), this,
- SLOT(onOperationStopped(ModuleBase_Operation*)));
+// connect(myWorkshop, SIGNAL(operationStarted(ModuleBase_Operation*)),
+// this, SLOT(onOperationStarted(ModuleBase_Operation*)));
- XGUI_Workshop* aXWshop = xWorkshop();
- XGUI_ContextMenuMgr* aContextMenuMgr = aXWshop->contextMenuMgr();
- connect(aContextMenuMgr, SIGNAL(actionTriggered(const QString&, bool)), this,
- SLOT(onContextMenuCommand(const QString&, bool)));
+// connect(myWorkshop, SIGNAL(operationStopped(ModuleBase_Operation*)), this,
+// SLOT(onOperationStopped(ModuleBase_Operation*)));
+
+ //XGUI_Workshop* aXWshop = xWorkshop();
+ //XGUI_ContextMenuMgr* aContextMenuMgr = aXWshop->contextMenuMgr();
+ //connect(aContextMenuMgr, SIGNAL(actionTriggered(const QString&, bool)), this,
+ // SLOT(onContextMenuCommand(const QString&, bool)));
}
{
}
-void PartSet_Module::createFeatures()
+void PartSet_Module::registerValidators()
{
//Registering of validators
SessionPtr aMgr = ModelAPI_Session::get();
aFactory->registerValidator("PartSet_PerpendicularValidator", new PartSet_PerpendicularValidator);
aFactory->registerValidator("PartSet_ParallelValidator", new PartSet_ParallelValidator);
aFactory->registerValidator("PartSet_RadiusValidator", new PartSet_RadiusValidator);
-
- Config_ModuleReader aXMLReader = Config_ModuleReader();
- aXMLReader.readAll();
- myFeaturesInFiles = aXMLReader.featuresInFiles();
}
-void PartSet_Module::featureCreated(QAction* theFeature)
+
+void PartSet_Module::onOperationComitted(ModuleBase_Operation* theOperation)
{
- connect(theFeature, SIGNAL(triggered(bool)), this, SLOT(onFeatureTriggered()));
+ if (theOperation->isEditOperation())
+ return;
+ /// Restart sketcher operations automatically
+ FeaturePtr aFeature = theOperation->feature();
+ std::shared_ptr<SketchPlugin_Feature> aSPFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+ if (aSPFeature && myRestartingMode) {
+ myLastOperationId = theOperation->id();
+ myLastFeature = theOperation->feature();
+ launchOperation(myLastOperationId);
+ } else {
+ breakOperationSequence();
+ }
}
-std::string PartSet_Module::featureFile(const std::string& theFeatureId)
+void PartSet_Module::breakOperationSequence()
{
- return myFeaturesInFiles[theFeatureId];
+ myLastOperationId = "";
+ myLastFeature = FeaturePtr();
+ myRestartingMode = false;
+
}
-/*
- *
- */
-void PartSet_Module::onFeatureTriggered()
+void PartSet_Module::onOperationAborted(ModuleBase_Operation* theOperation)
{
- QAction* aCmd = dynamic_cast<QAction*>(sender());
- //Do nothing on uncheck
- if (aCmd->isCheckable() && !aCmd->isChecked())
- return;
- launchOperation(aCmd->data().toString());
+ breakOperationSequence();
}
-
void PartSet_Module::onOperationStarted(ModuleBase_Operation* theOperation)
{
- XGUI_Workshop* aXWshp = xWorkshop();
- XGUI_Displayer* aDisplayer = aXWshp->displayer();
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(theOperation);
- if (aPreviewOp) {
- XGUI_PropertyPanel* aPropPanel = aXWshp->propertyPanel();
- connect(aPropPanel, SIGNAL(storedPoint2D(ObjectPtr, const std::string&)), this,
- SLOT(onStorePoint2D(ObjectPtr, const std::string&)), Qt::UniqueConnection);
-
- //aDisplayer->deactivateObjectsOutOfContext();
- PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
- if (aSketchOp) {
- if (aSketchOp->isEditOperation()) {
- setSketchingMode(getSketchPlane(aSketchOp->feature()));
- } else {
- aDisplayer->openLocalContext();
- aDisplayer->activateObjectsOutOfContext(QIntList());
- myPlaneFilter = new StdSelect_FaceFilter(StdSelect_Plane);
- aDisplayer->addSelectionFilter(myPlaneFilter);
- QIntList aModes = sketchSelectionModes(aPreviewOp->feature());
- aDisplayer->setSelectionModes(aModes);
- }
+ myRestartingMode = true;
+ if (theOperation->id().toStdString() == SketchPlugin_Sketch::ID()) {
+ // Display all sketcher sub-Objects
+ myCurrentSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theOperation->feature());
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+
+ for (int i = 0; i < myCurrentSketch->numberOfSubs(); i++) {
+ FeaturePtr aFeature = myCurrentSketch->subFeature(i);
+ std::list<ResultPtr> aResults = aFeature->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+ aDisplayer->display((*aIt), false);
+ }
+ aDisplayer->display(aFeature);
}
+ // Hide sketcher result
+ std::list<ResultPtr> aResults = myCurrentSketch->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+ aDisplayer->erase((*aIt), false);
+ }
+ aDisplayer->erase(myCurrentSketch);
}
}
void PartSet_Module::onOperationStopped(ModuleBase_Operation* theOperation)
{
- if (!theOperation)
- return;
- XGUI_Workshop* aXWshp = xWorkshop();
- XGUI_Displayer* aDisplayer = aXWshp->displayer();
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(theOperation);
- if (aPreviewOp) {
- XGUI_PropertyPanel* aPropPanel = aXWshp->propertyPanel();
-
- PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
- if (aSketchOp) {
- aDisplayer->closeLocalContexts();
- } else {
- PartSet_OperationFeatureCreate* aCreationOp =
- dynamic_cast<PartSet_OperationFeatureCreate*>(aPreviewOp);
- if (aCreationOp) {
- // Activate just created object for selection
- FeaturePtr aFeature = aCreationOp->feature();
- QIntList aModes = sketchSelectionModes(aFeature);
- const std::list<ResultPtr>& aResults = aFeature->results();
- std::list<ResultPtr>::const_iterator anIt, aLast = aResults.end();
- for (anIt = aResults.begin(); anIt != aLast; anIt++) {
- aDisplayer->activate(*anIt, aModes);
- }
- aDisplayer->activate(aFeature, aModes);
- aDisplayer->clearSelected();
+ if (theOperation->id().toStdString() == SketchPlugin_Sketch::ID()) {
+ // Hide all sketcher sub-Objects
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+
+ for (int i = 0; i < myCurrentSketch->numberOfSubs(); i++) {
+ FeaturePtr aFeature = myCurrentSketch->subFeature(i);
+ std::list<ResultPtr> aResults = aFeature->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+ aDisplayer->erase((*aIt), false);
}
+ aDisplayer->erase(aFeature, false);
}
- }// else {
- // Activate results of current feature for selection
- //FeaturePtr aFeature = theOperation->feature();
- //XGUI_Displayer* aDisplayer = aXWshp->displayer();
- //std::list<ResultPtr> aResults = aFeature->results();
- //std::list<ResultPtr>::const_iterator aIt;
- //for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
- // aDisplayer->activate(*aIt);
- //}
- //}
-}
-
-void PartSet_Module::onContextMenuCommand(const QString& theId, bool isChecked)
-{
- QList<ObjectPtr> aFeatures = workshop()->selection()->selectedObjects();
- if (theId == "EDIT_CMD" && (aFeatures.size() > 0)) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aFeatures.first());
- if (aFeature)
- editFeature(aFeature);
+ // Display sketcher result
+ std::list<ResultPtr> aResults = myCurrentSketch->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+ aDisplayer->display((*aIt), false);
+ }
+ aDisplayer->display(myCurrentSketch);
+
+ myCurrentSketch = CompositeFeaturePtr();
}
}
-void PartSet_Module::onMousePressed(QMouseEvent* theEvent)
-{
- XGUI_Workshop* aXWshp = xWorkshop();
- PartSet_OperationSketchBase* aPreviewOp =
- dynamic_cast<PartSet_OperationSketchBase*>(workshop()->currentOperation());
- if (aPreviewOp) {
- ModuleBase_ISelection* aSelection = workshop()->selection();
- aPreviewOp->mousePressed(theEvent, myWorkshop->viewer(), aSelection);
- }
-}
-void PartSet_Module::onMouseReleased(QMouseEvent* theEvent)
+
+void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
{
- PartSet_OperationSketchBase* aPreviewOp =
- dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- if (aPreviewOp) {
- ModuleBase_ISelection* aSelection = workshop()->selection();
- // Initialise operation with preliminary selection
- aPreviewOp->mouseReleased(theEvent, myWorkshop->viewer(), aSelection);
+ if ((theOperation->id() == myLastOperationId) && myLastFeature) {
+ ModuleBase_ModelWidget* aWgt = theOperation->propertyPanel()->activeWidget();
+ if (theOperation->id().toStdString() == SketchPlugin_Line::ID()) {
+ PartSet_WidgetPoint2D* aPnt2dWgt = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
+ if (aPnt2dWgt) {
+ std::shared_ptr<ModelAPI_Data> aData = myLastFeature->data();
+ std::shared_ptr<GeomDataAPI_Point2D> aPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Line::END_ID()));
+ if (aPoint) {
+ aPnt2dWgt->setPoint(aPoint->x(), aPoint->y());
+ PartSet_Tools::setConstraints(myCurrentSketch, theOperation->feature(),
+ SketchPlugin_Line::START_ID(), aPoint->x(), aPoint->y());
+ theOperation->propertyPanel()->activateNextWidget(aPnt2dWgt);
+ }
+ }
+ }
}
}
-void PartSet_Module::onMouseMoved(QMouseEvent* theEvent)
-{
- PartSet_OperationSketchBase* aPreviewOp =
- dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- if (aPreviewOp)
- aPreviewOp->mouseMoved(theEvent, myWorkshop->viewer());
-}
-void PartSet_Module::onKeyRelease(QKeyEvent* theEvent)
+void PartSet_Module::onSelectionChanged()
{
- ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
- if (aPreviewOp) {
- aPreviewOp->keyReleased(theEvent->key());
- }
+ // Activate edit operation for sketcher objects
+ //ModuleBase_ISelection* aSelect = myWorkshop->selection();
+ //QObjectPtrList aObjects = aSelect->selectedPresentations();
+ //if (aObjects.size() == 1) {
+ // FeaturePtr aFeature = ModelAPI_Feature::feature(aObjects.first());
+ // if (aFeature) {
+ // std::shared_ptr<SketchPlugin_Feature> aSPFeature =
+ // std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+ // if (aSPFeature) {
+ // editFeature(aSPFeature);
+ // }
+ // }
+ //}
}
-void PartSet_Module::onMouseDoubleClick(QMouseEvent* theEvent)
-{
- PartSet_OperationSketchBase* aPreviewOp =
- dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- Handle(V3d_View) aView = myWorkshop->viewer()->activeView();
- if (aPreviewOp && (!aView.IsNull())) {
- ModuleBase_ISelection* aSelection = workshop()->selection();
- // Initialise operation with preliminary selection
- aPreviewOp->mouseDoubleClick(theEvent, aView, aSelection);
- }
-}
+//ModuleBase_Operation* PartSet_Module::getNewOperation(const std::string& theFeatureId)
+//{
+// ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+// if (aOperation) {
+// // If the current operation is sketcher sub-operation then we have to create
+// // Costomized operation
+// if (aOperation->id().toStdString() == SketchPlugin_Sketch::ID()) {
+// PartSet_Operation* aPSOp = new PartSet_Operation(theFeatureId.c_str(), this);
+// aPSOp->setWorkshop(myWorkshop);
+// connect(myWorkshop, SIGNAL(selectionChanged()), aPSOp, SLOT(onSelectionChanged()));
+// return aPSOp;
+// }
+// }
+// return ModuleBase_IModule::getNewOperation(theFeatureId);
+//}
-void PartSet_Module::onPlaneSelected(double theX, double theY, double theZ)
-{
- myWorkshop->viewer()->setViewProjection(theX, theY, theZ);
-}
-void PartSet_Module::onSketchLaunched()
+void PartSet_Module::onMousePressed(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
{
- xWorkshop()->actionsMgr()->update();
- // Set working plane
- ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- FeaturePtr aSketch = anOperation->feature();
- setSketchingMode(getSketchPlane(aSketch));
-}
+ if (!(theEvent->buttons() & Qt::LeftButton))
+ return;
+ ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+ // Use only for sketch operations
+ if (aOperation && myCurrentSketch) {
+ if (!PartSet_Tools::sketchPlane(myCurrentSketch))
+ return;
-void PartSet_Module::onFitAllView()
-{
- myWorkshop->viewer()->fitAll();
-}
+ bool isSketcher = (aOperation->id().toStdString() == SketchPlugin_Sketch::ID());
+ bool isSketchOpe = sketchOperationIdList().contains(aOperation->id());
-void PartSet_Module::onRestartOperation(std::string theName, ObjectPtr theObject)
-{
- FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
-
- std::string aKind = aFeature ? aFeature->getKind() : "";
- ModuleBase_Operation* anOperation = createOperation(theName, aKind);
-
- PartSet_OperationSketchBase* aSketchOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
- if (aSketchOp) {
- PartSet_OperationFeatureCreate* aCreateOp = dynamic_cast<PartSet_OperationFeatureCreate*>(anOperation);
- if (aCreateOp)
- aCreateOp->initFeature(aFeature);
- else {
- anOperation->setFeature(aFeature);
- }
- ModuleBase_ISelection* aSelection = workshop()->selection();
- // Initialise operation with preliminary selection
- aSketchOp->initSelection(aSelection, myWorkshop->viewer());
- } else if (aFeature) { // In case of edit operation: set the previously created feature to the operation
- anOperation->setFeature(aFeature);
- ////Deactivate result of current feature in order to avoid its selection
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- std::list<ResultPtr> aResults = aFeature->results();
- std::list<ResultPtr>::const_iterator aIt;
- for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
- aDisplayer->deactivate(*aIt);
+ // Avoid non-sketch operations
+ if (!isSketchOpe)
+ return;
+
+ bool isEditing = aOperation->isEditOperation();
+
+ // Ignore creation sketch operation
+ if ((!isSketcher) && (!isEditing))
+ return;
+
+ // Remember highlighted objects for editing
+ ModuleBase_ISelection* aSelect = myWorkshop->selection();
+ QList<ModuleBase_ViewerPrs> aObjects = aSelect->getHighlighted();
+ myEditingFeatures.clear();
+ if (aObjects.size() > 0) {
+ foreach(ModuleBase_ViewerPrs aPrs, aObjects) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aObjects.first().object());
+ if (aFeature)
+ myEditingFeatures.append(aFeature);
+ }
+ }
+ // If nothing highlighted - return
+ if (myEditingFeatures.size() == 0)
+ return;
+
+ if (isSketcher) {
+ CompositeFeaturePtr aSketch =
+ std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aOperation->feature());
+ if (!PartSet_Tools::sketchPlane(aSketch))
+ return;
+
+ //myCurrentSketch = aOperation->feature();
+ myIsDragging = true;
+ get2dPoint(theWnd, theEvent, myCurX, myCurY);
+ myDragDone = false;
+ myWorkshop->viewer()->enableSelection(false);
+
+ launchEditing();
+
+ } else if (isSketchOpe && isEditing) {
+ aOperation->abort();
+
+ //myCurrentSketch = aOperation->parentFeature();
+ myIsDragging = true;
+ get2dPoint(theWnd, theEvent, myCurX, myCurY);
+ myDragDone = false;
+ myWorkshop->viewer()->enableSelection(false);
+
+ QTimer::singleShot(10, this, SLOT(launchEditing()));
}
}
- sendOperation(anOperation);
- xWorkshop()->actionsMgr()->updateCheckState();
}
-void PartSet_Module::onMultiSelectionEnabled(bool theEnabled)
-{
- ModuleBase_IViewer* aViewer = myWorkshop->viewer();
- aViewer->enableMultiselection(theEnabled);
-}
-void PartSet_Module::onStopSelection(const QList<ObjectPtr>& theFeatures, const bool isStop)
+void PartSet_Module::get2dPoint(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent,
+ double& theX, double& theY)
{
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- //if (!isStop) {
- // foreach(ObjectPtr aObject, theFeatures) {
- // activateFeature(aObject);
- // }
- //}
- aDisplayer->stopSelection(theFeatures, isStop, false);
-
- ModuleBase_IViewer* aViewer = myWorkshop->viewer();
- aViewer->enableSelection(!isStop);
-
- aDisplayer->updateViewer();
+ Handle(V3d_View) aView = theWnd->v3dView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
+ PartSet_Tools::convertTo2D(aPoint, myCurrentSketch, aView, theX, theY);
}
-void PartSet_Module::onSetSelection(const QList<ObjectPtr>& theFeatures)
+
+void PartSet_Module::launchEditing()
{
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- aDisplayer->setSelected(theFeatures, false);
- aDisplayer->updateViewer();
+ if (myEditingFeatures.size() == 1) {
+ FeaturePtr aFeature = myEditingFeatures.first();
+ std::shared_ptr<SketchPlugin_Feature> aSPFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+ if (aSPFeature) {
+ editFeature(aSPFeature);
+ }
+ }
}
-void PartSet_Module::setSketchingMode(const gp_Pln& thePln)
+void PartSet_Module::onMouseReleased(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
{
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- if (!myPlaneFilter.IsNull()) {
- aDisplayer->removeSelectionFilter(myPlaneFilter);
- myPlaneFilter.Nullify();
+ if (myIsDragging) {
+ myIsDragging = false;
+ myWorkshop->viewer()->enableSelection(true);
+ if (myDragDone)
+ myWorkshop->currentOperation()->commit();
}
- QIntList aModes;
- // Clear standard selection modes
- aDisplayer->setSelectionModes(aModes);
- aDisplayer->openLocalContext();
-
- // 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)
+
+void PartSet_Module::onMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
{
- bool isDisplay = theMode != PartSet_OperationSketchBase::FM_Hide;
- ModuleBase_Operation* aCurOperation = myWorkshop->currentOperation();
- PartSet_OperationSketchBase* aPrevOp = dynamic_cast<PartSet_OperationSketchBase*>(aCurOperation);
- if (aPrevOp) {
- std::list<FeaturePtr> aList = aPrevOp->subFeatures();
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- QIntList aModes = sketchSelectionModes(aPrevOp->feature());
- std::list<FeaturePtr>::iterator aSFIt;
- for (aSFIt = aList.begin(); aSFIt != aList.end(); ++aSFIt) {
- std::list<ResultPtr> aResults = (*aSFIt)->results();
- std::list<ResultPtr>::iterator aIt;
- for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
- if (!isDisplay)
- aDisplayer->erase((*aIt), false);
+ if (myIsDragging) {
+ Handle(V3d_View) aView = theWnd->v3dView();
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
+ double aX, aY;
+ PartSet_Tools::convertTo2D(aPoint, myCurrentSketch, aView, aX, aY);
+ double dX = myCurX - aX;
+ double dY = myCurY - aY;
+
+ ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+ ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
+ QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
+ foreach(ModuleBase_ModelWidget* aWgt, aWidgets) {
+ PartSet_WidgetPoint2D* aWgt2d = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
+ if (aWgt2d) {
+ aWgt2d->setPoint(aWgt2d->x() - dX, aWgt2d->y() - dY);
}
- if (!isDisplay)
- aDisplayer->erase((*aSFIt), false);
}
- //aDisplayer->deactivateObjectsOutOfContext();
+ myDragDone = true;
+ myCurX = aX;
+ myCurY = aY;
}
- if (isDisplay)
- ModelAPI_EventCreator::get()->sendUpdated(
- theFeature, Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
}
-ModuleBase_Operation* PartSet_Module::createOperation(const std::string& theCmdId,
- const std::string& theFeatureKind)
-{
- // create the operation
- ModuleBase_Operation* anOperation = 0;
- if (theCmdId == PartSet_OperationSketch::Type()) {
- anOperation = new PartSet_OperationSketch(theCmdId.c_str(), this);
- } else {
- ModuleBase_Operation* aCurOperation = myWorkshop->currentOperation();
- CompositeFeaturePtr aSketch;
- PartSet_OperationSketchBase* aPrevOp = dynamic_cast<PartSet_OperationSketchBase*>(aCurOperation);
- if (aPrevOp) {
- aSketch = aPrevOp->sketch();
- }
- if (PartSet_OperationFeatureCreate::canProcessKind(theCmdId)) {
- anOperation = new PartSet_OperationFeatureCreate(theCmdId.c_str(), this, aSketch);
- } else if (theCmdId == PartSet_OperationFeatureEdit::Type()) {
- anOperation = new PartSet_OperationFeatureEdit(theCmdId.c_str(), this, aSketch);
- }
- }
- if (!anOperation) {
- anOperation = new ModuleBase_Operation(theCmdId.c_str(), this);
- }
+QStringList PartSet_Module::sketchOperationIdList() const
+{
+ QStringList aIds;
+ aIds << SketchPlugin_Sketch::ID().c_str();
+ aIds << SketchPlugin_Line::ID().c_str();
+ aIds << SketchPlugin_Point::ID().c_str();
+ aIds << SketchPlugin_Arc::ID().c_str();
+ aIds << SketchPlugin_Circle::ID().c_str();
+ return aIds;
+}
- // set operation description and list of widgets corresponding to the feature xml definition
- std::string aFeatureKind = theFeatureKind.empty() ? theCmdId : theFeatureKind;
-
- std::string aPluginFileName = featureFile(aFeatureKind);
- Config_WidgetReader aWdgReader = Config_WidgetReader(aPluginFileName);
- aWdgReader.readAll();
- std::string aXmlCfg = aWdgReader.featureWidgetCfg(aFeatureKind);
- std::string aDescription = aWdgReader.featureDescription(aFeatureKind);
-
- anOperation->getDescription()->setDescription(QString::fromStdString(aDescription));
- anOperation->getDescription()->setXmlRepresentation(QString::fromStdString(aXmlCfg));
-
- // connect the operation
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
- if (aPreviewOp) {
- connect(aPreviewOp, SIGNAL(featureConstructed(ObjectPtr, int)), this,
- SLOT(onFeatureConstructed(ObjectPtr, int)));
- connect(aPreviewOp, SIGNAL(restartRequired(std::string, ObjectPtr)), this,
- SLOT(onRestartOperation(std::string, ObjectPtr)));
- // 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)));
- connect(aPreviewOp, SIGNAL(setSelection(const QList<ObjectPtr>&)), this,
- SLOT(onSetSelection(const QList<ObjectPtr>&)));
-
- PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
- if (aSketchOp) {
- connect(aSketchOp, SIGNAL(planeSelected(double, double, double)), this,
- SLOT(onPlaneSelected(double, double, double)));
- connect(aSketchOp, SIGNAL(fitAllView()), this, SLOT(onFitAllView()));
- connect(aSketchOp, SIGNAL(launchSketch()), this, SLOT(onSketchLaunched()));
+void PartSet_Module::onVertexSelected(ObjectPtr theObject, const TopoDS_Shape& theShape)
+{
+ ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+ if (aOperation->id().toStdString() == SketchPlugin_Line::ID()) {
+ /// If last line finished on vertex the lines creation sequence has to be break
+ ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
+ const QList<ModuleBase_ModelWidget*>& aWidgets = aPanel->modelWidgets();
+ if (aWidgets.last() == aPanel->activeWidget()) {
+ breakOperationSequence();
+ PartSet_WidgetPoint2D* aPnt2dWgt = dynamic_cast<PartSet_WidgetPoint2D*>(aPanel->activeWidget());
+ PartSet_Tools::setConstraints(myCurrentSketch, aOperation->feature(),
+ SketchPlugin_Line::END_ID(), aPnt2dWgt->x(), aPnt2dWgt->y());
}
}
-
- return anOperation;
}
-void PartSet_Module::updateCurrentPreview(const std::string& theCmdId)
-{
- ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- if (!anOperation)
- return;
+//void PartSet_Module::featureCreated(QAction* theFeature)
+//{
+// connect(theFeature, SIGNAL(triggered(bool)), this, SLOT(onFeatureTriggered()));
+//}
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
- if (!aPreviewOp)
- return;
+//std::string PartSet_Module::featureFile(const std::string& theFeatureId)
+//{
+// return myFeaturesInFiles[theFeatureId];
+//}
- FeaturePtr aFeature = aPreviewOp->feature();
- if (!aFeature || aFeature->getKind() != theCmdId)
- return;
+/*
+ *
+ */
+//void PartSet_Module::onFeatureTriggered()
+//{
+// QAction* aCmd = dynamic_cast<QAction*>(sender());
+// //Do nothing on uncheck
+// if (aCmd->isCheckable() && !aCmd->isChecked())
+// return;
+// launchOperation(aCmd->data().toString());
+//}
+
+
+//void PartSet_Module::onOperationStarted(ModuleBase_Operation* theOperation)
+//{
+// XGUI_Workshop* aXWshp = xWorkshop();
+// XGUI_Displayer* aDisplayer = aXWshp->displayer();
+// PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(theOperation);
+// if (aPreviewOp) {
+// XGUI_PropertyPanel* aPropPanel = aXWshp->propertyPanel();
+// connect(aPropPanel, SIGNAL(storedPoint2D(ObjectPtr, const std::string&)), this,
+// SLOT(onStorePoint2D(ObjectPtr, const std::string&)), Qt::UniqueConnection);
+//
+// //aDisplayer->deactivateObjectsOutOfContext();
+// PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
+// if (aSketchOp) {
+// if (aSketchOp->isEditOperation()) {
+// setSketchingMode(getSketchPlane(aSketchOp->feature()));
+// } else {
+// aDisplayer->openLocalContext();
+// aDisplayer->activateObjectsOutOfContext(QIntList());
+// myPlaneFilter = new StdSelect_FaceFilter(StdSelect_Plane);
+// aDisplayer->addSelectionFilter(myPlaneFilter);
+// QIntList aModes = sketchSelectionModes(aPreviewOp->feature());
+// aDisplayer->setSelectionModes(aModes);
+// }
+// }
+// }
+//}
+
+//void PartSet_Module::onOperationStopped(ModuleBase_Operation* theOperation)
+//{
+// if (!theOperation)
+// return;
+// XGUI_Workshop* aXWshp = xWorkshop();
+// XGUI_Displayer* aDisplayer = aXWshp->displayer();
+// PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(theOperation);
+// if (aPreviewOp) {
+// XGUI_PropertyPanel* aPropPanel = aXWshp->propertyPanel();
+//
+// PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
+// if (aSketchOp) {
+// aDisplayer->closeLocalContexts();
+// } else {
+// PartSet_OperationFeatureCreate* aCreationOp =
+// dynamic_cast<PartSet_OperationFeatureCreate*>(aPreviewOp);
+// if (aCreationOp) {
+// // Activate just created object for selection
+// FeaturePtr aFeature = aCreationOp->feature();
+// QIntList aModes = sketchSelectionModes(aFeature);
+// const std::list<ResultPtr>& aResults = aFeature->results();
+// std::list<ResultPtr>::const_iterator anIt, aLast = aResults.end();
+// for (anIt = aResults.begin(); anIt != aLast; anIt++) {
+// aDisplayer->activate(*anIt, aModes);
+// }
+// aDisplayer->activate(aFeature, aModes);
+// aDisplayer->clearSelected();
+// }
+// }
+// }// else {
+// // Activate results of current feature for selection
+// //FeaturePtr aFeature = theOperation->feature();
+// //XGUI_Displayer* aDisplayer = aXWshp->displayer();
+// //std::list<ResultPtr> aResults = aFeature->results();
+// //std::list<ResultPtr>::const_iterator aIt;
+// //for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+// // aDisplayer->activate(*aIt);
+// //}
+// //}
+//}
+
+//void PartSet_Module::onContextMenuCommand(const QString& theId, bool isChecked)
+//{
+// QList<ObjectPtr> aFeatures = workshop()->selection()->selectedObjects();
+// if (theId == "EDIT_CMD" && (aFeatures.size() > 0)) {
+// FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aFeatures.first());
+// if (aFeature)
+// editFeature(aFeature);
+// }
+//}
+
+//void PartSet_Module::onMousePressed(QMouseEvent* theEvent)
+//{
+// XGUI_Workshop* aXWshp = xWorkshop();
+// PartSet_OperationSketchBase* aPreviewOp =
+// dynamic_cast<PartSet_OperationSketchBase*>(workshop()->currentOperation());
+// if (aPreviewOp) {
+// ModuleBase_ISelection* aSelection = workshop()->selection();
+// aPreviewOp->mousePressed(theEvent, myWorkshop->viewer(), aSelection);
+// }
+//}
+
+//void PartSet_Module::onMouseReleased(QMouseEvent* theEvent)
+//{
+// PartSet_OperationSketchBase* aPreviewOp =
+// dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
+// if (aPreviewOp) {
+// ModuleBase_ISelection* aSelection = workshop()->selection();
+// // Initialise operation with preliminary selection
+// aPreviewOp->mouseReleased(theEvent, myWorkshop->viewer(), aSelection);
+// }
+//}
+
+//void PartSet_Module::onMouseMoved(QMouseEvent* theEvent)
+//{
+// PartSet_OperationSketchBase* aPreviewOp =
+// dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
+// if (aPreviewOp)
+// aPreviewOp->mouseMoved(theEvent, myWorkshop->viewer());
+//}
+
+//void PartSet_Module::onKeyRelease(QKeyEvent* theEvent)
+//{
+// ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
+// PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
+// if (aPreviewOp) {
+// aPreviewOp->keyReleased(theEvent->key());
+// }
+//}
+
+//void PartSet_Module::onMouseDoubleClick(QMouseEvent* theEvent)
+//{
+// PartSet_OperationSketchBase* aPreviewOp =
+// dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
+// Handle(V3d_View) aView = myWorkshop->viewer()->activeView();
+// if (aPreviewOp && (!aView.IsNull())) {
+// ModuleBase_ISelection* aSelection = workshop()->selection();
+// // Initialise operation with preliminary selection
+// aPreviewOp->mouseDoubleClick(theEvent, aView, aSelection);
+// }
+//}
+
+//void PartSet_Module::onPlaneSelected(double theX, double theY, double theZ)
+//{
+// myWorkshop->viewer()->setViewProjection(theX, theY, theZ);
+//}
+
+//void PartSet_Module::onSketchLaunched()
+//{
+// xWorkshop()->actionsMgr()->update();
+// // Set working plane
+// ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
+// FeaturePtr aSketch = anOperation->feature();
+// setSketchingMode(getSketchPlane(aSketch));
+//}
+
+//void PartSet_Module::onFitAllView()
+//{
+// myWorkshop->viewer()->fitAll();
+//}
+
+//void PartSet_Module::onRestartOperation(std::string theName, ObjectPtr theObject)
+//{
+// FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+//
+// std::string aKind = aFeature ? aFeature->getKind() : "";
+// ModuleBase_Operation* anOperation = createOperation(theName, aKind);
+//
+// PartSet_OperationSketchBase* aSketchOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
+// if (aSketchOp) {
+// PartSet_OperationFeatureCreate* aCreateOp = dynamic_cast<PartSet_OperationFeatureCreate*>(anOperation);
+// if (aCreateOp)
+// aCreateOp->initFeature(aFeature);
+// else {
+// anOperation->setFeature(aFeature);
+// }
+// ModuleBase_ISelection* aSelection = workshop()->selection();
+// // Initialise operation with preliminary selection
+// aSketchOp->initSelection(aSelection, myWorkshop->viewer());
+// } else if (aFeature) { // In case of edit operation: set the previously created feature to the operation
+// anOperation->setFeature(aFeature);
+// ////Deactivate result of current feature in order to avoid its selection
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// std::list<ResultPtr> aResults = aFeature->results();
+// std::list<ResultPtr>::const_iterator aIt;
+// for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+// aDisplayer->deactivate(*aIt);
+// }
+// }
+// sendOperation(anOperation);
+// xWorkshop()->actionsMgr()->updateCheckState();
+//}
+
+//void PartSet_Module::onMultiSelectionEnabled(bool theEnabled)
+//{
+// ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+// aViewer->enableMultiselection(theEnabled);
+//}
+
+//void PartSet_Module::onStopSelection(const QList<ObjectPtr>& theFeatures, const bool isStop)
+//{
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// //if (!isStop) {
+// // foreach(ObjectPtr aObject, theFeatures) {
+// // activateFeature(aObject);
+// // }
+// //}
+// aDisplayer->stopSelection(theFeatures, isStop, false);
+//
+// ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+// aViewer->enableSelection(!isStop);
+//
+// aDisplayer->updateViewer();
+//}
+
+//void PartSet_Module::onSetSelection(const QList<ObjectPtr>& theFeatures)
+//{
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// aDisplayer->setSelected(theFeatures, false);
+// aDisplayer->updateViewer();
+//}
+
+//void PartSet_Module::setSketchingMode(const gp_Pln& thePln)
+//{
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// if (!myPlaneFilter.IsNull()) {
+// aDisplayer->removeSelectionFilter(myPlaneFilter);
+// myPlaneFilter.Nullify();
+// }
+// QIntList aModes;
+// // Clear standard selection modes
+// aDisplayer->setSelectionModes(aModes);
+// aDisplayer->openLocalContext();
+//
+// // 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)
+//{
+// bool isDisplay = theMode != PartSet_OperationSketchBase::FM_Hide;
+// ModuleBase_Operation* aCurOperation = myWorkshop->currentOperation();
+// PartSet_OperationSketchBase* aPrevOp = dynamic_cast<PartSet_OperationSketchBase*>(aCurOperation);
+// if (aPrevOp) {
+// std::list<FeaturePtr> aList = aPrevOp->subFeatures();
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// QIntList aModes = sketchSelectionModes(aPrevOp->feature());
+// std::list<FeaturePtr>::iterator aSFIt;
+// for (aSFIt = aList.begin(); aSFIt != aList.end(); ++aSFIt) {
+// std::list<ResultPtr> aResults = (*aSFIt)->results();
+// std::list<ResultPtr>::iterator aIt;
+// for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+// if (!isDisplay)
+// aDisplayer->erase((*aIt), false);
+// }
+// if (!isDisplay)
+// aDisplayer->erase((*aSFIt), false);
+// }
+// //aDisplayer->deactivateObjectsOutOfContext();
+// }
+// if (isDisplay)
+// ModelAPI_EventCreator::get()->sendUpdated(
+// theFeature, Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
+//}
+
+//ModuleBase_Operation* PartSet_Module::createOperation(const std::string& theCmdId,
+// const std::string& theFeatureKind)
+//{
+// // create the operation
+// ModuleBase_Operation* anOperation = 0;
+// if (theCmdId == PartSet_OperationSketch::Type()) {
+// anOperation = new PartSet_OperationSketch(theCmdId.c_str(), this);
+// } else {
+// ModuleBase_Operation* aCurOperation = myWorkshop->currentOperation();
+// CompositeFeaturePtr aSketch;
+// PartSet_OperationSketchBase* aPrevOp = dynamic_cast<PartSet_OperationSketchBase*>(aCurOperation);
+// if (aPrevOp) {
+// aSketch = aPrevOp->sketch();
+// }
+// if (PartSet_OperationFeatureCreate::canProcessKind(theCmdId)) {
+// anOperation = new PartSet_OperationFeatureCreate(theCmdId.c_str(), this, aSketch);
+// } else if (theCmdId == PartSet_OperationFeatureEdit::Type()) {
+// anOperation = new PartSet_OperationFeatureEdit(theCmdId.c_str(), this, aSketch);
+// }
+// }
+//
+// if (!anOperation) {
+// anOperation = new ModuleBase_Operation(theCmdId.c_str(), this);
+// }
+//
+// // set operation description and list of widgets corresponding to the feature xml definition
+// std::string aFeatureKind = theFeatureKind.empty() ? theCmdId : theFeatureKind;
+//
+// std::string aPluginFileName = featureFile(aFeatureKind);
+// Config_WidgetReader aWdgReader = Config_WidgetReader(aPluginFileName);
+// aWdgReader.readAll();
+// std::string aXmlCfg = aWdgReader.featureWidgetCfg(aFeatureKind);
+// std::string aDescription = aWdgReader.featureDescription(aFeatureKind);
+//
+// anOperation->getDescription()->setDescription(QString::fromStdString(aDescription));
+// anOperation->getDescription()->setXmlRepresentation(QString::fromStdString(aXmlCfg));
+//
+// // connect the operation
+// PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
+// if (aPreviewOp) {
+// connect(aPreviewOp, SIGNAL(featureConstructed(ObjectPtr, int)), this,
+// SLOT(onFeatureConstructed(ObjectPtr, int)));
+// connect(aPreviewOp, SIGNAL(restartRequired(std::string, ObjectPtr)), this,
+// SLOT(onRestartOperation(std::string, ObjectPtr)));
+// // 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)));
+// connect(aPreviewOp, SIGNAL(setSelection(const QList<ObjectPtr>&)), this,
+// SLOT(onSetSelection(const QList<ObjectPtr>&)));
+//
+// PartSet_OperationSketch* aSketchOp = dynamic_cast<PartSet_OperationSketch*>(aPreviewOp);
+// if (aSketchOp) {
+// connect(aSketchOp, SIGNAL(planeSelected(double, double, double)), this,
+// SLOT(onPlaneSelected(double, double, double)));
+// connect(aSketchOp, SIGNAL(fitAllView()), this, SLOT(onFitAllView()));
+// connect(aSketchOp, SIGNAL(launchSketch()), this, SLOT(onSketchLaunched()));
+// }
+// }
+//
+// return anOperation;
+//}
+
+
+//void PartSet_Module::updateCurrentPreview(const std::string& theCmdId)
+//{
+// ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
+// if (!anOperation)
+// return;
+//
+// PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(anOperation);
+// if (!aPreviewOp)
+// return;
+//
+// FeaturePtr aFeature = aPreviewOp->feature();
+// if (!aFeature || aFeature->getKind() != theCmdId)
+// return;
+//
+// XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
+// // Hide result of sketch
+// std::list<ResultPtr> aResults = aFeature->results();
+// std::list<ResultPtr>::const_iterator aIt;
+// for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt)
+// aDisplayer->erase(*aIt, false);
+//
+// std::list<FeaturePtr> aList = aPreviewOp->subFeatures();
+//
+// std::list<FeaturePtr>::const_iterator anIt = aList.begin(), aLast = aList.end();
+// for (; anIt != aLast; anIt++) {
+// std::shared_ptr<SketchPlugin_Feature> aSPFeature = std::dynamic_pointer_cast<
+// SketchPlugin_Feature>(*anIt);
+// if (!aSPFeature)
+// continue;
+// std::list<ResultPtr> aResults = aSPFeature->results();
+// std::list<ResultPtr>::const_iterator aRIt;
+// for (aRIt = aResults.cbegin(); aRIt != aResults.cend(); ++aRIt) {
+// aDisplayer->display((*aRIt), false);
+// aDisplayer->activate((*aRIt), sketchSelectionModes((*aRIt)));
+// }
+// aDisplayer->display(aSPFeature, false);
+// aDisplayer->activate(aSPFeature, sketchSelectionModes(aSPFeature));
+// }
+// aDisplayer->updateViewer();
+//}
- XGUI_Displayer* aDisplayer = xWorkshop()->displayer();
- // Hide result of sketch
- std::list<ResultPtr> aResults = aFeature->results();
- std::list<ResultPtr>::const_iterator aIt;
- for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt)
- aDisplayer->erase(*aIt, false);
-
- std::list<FeaturePtr> aList = aPreviewOp->subFeatures();
-
- std::list<FeaturePtr>::const_iterator anIt = aList.begin(), aLast = aList.end();
- for (; anIt != aLast; anIt++) {
- std::shared_ptr<SketchPlugin_Feature> aSPFeature = std::dynamic_pointer_cast<
- SketchPlugin_Feature>(*anIt);
- if (!aSPFeature)
- continue;
- std::list<ResultPtr> aResults = aSPFeature->results();
- std::list<ResultPtr>::const_iterator aRIt;
- for (aRIt = aResults.cbegin(); aRIt != aResults.cend(); ++aRIt) {
- aDisplayer->display((*aRIt), false);
- aDisplayer->activate((*aRIt), sketchSelectionModes((*aRIt)));
- }
- aDisplayer->display(aSPFeature, false);
- aDisplayer->activate(aSPFeature, sketchSelectionModes(aSPFeature));
- }
- aDisplayer->updateViewer();
-}
-
-void PartSet_Module::editFeature(FeaturePtr theFeature)
-{
- if (!theFeature)
- return;
+//void PartSet_Module::editFeature(FeaturePtr theFeature)
+//{
+// if (!theFeature)
+// return;
// if (theFeature->getKind() == SKETCH_KIND) {
//FeaturePtr aFeature = theFeature;
//}
//if (aFeature) {
- onRestartOperation(theFeature->getKind(), theFeature);
- updateCurrentPreview(theFeature->getKind());
+// onRestartOperation(theFeature->getKind(), theFeature);
+// updateCurrentPreview(theFeature->getKind());
//}
// }
-}
-
-void PartSet_Module::onStorePoint2D(ObjectPtr theFeature, const std::string& theAttribute)
-{
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature);
-
- PartSet_OperationSketchBase* aPreviewOp =
- dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
- if (!aPreviewOp)
- return;
-
- std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aFeature->data()->attribute(theAttribute));
-
- PartSet_Tools::setConstraints(aPreviewOp->sketch(), aFeature, theAttribute, aPoint->x(),
- aPoint->y());
-}
+//}
+
+//void PartSet_Module::onStorePoint2D(ObjectPtr theFeature, const std::string& theAttribute)
+//{
+// FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature);
+//
+// PartSet_OperationSketchBase* aPreviewOp =
+
// dynamic_cast<PartSet_OperationSketchBase*>(myWorkshop->currentOperation());
+// if (!aPreviewOp)
+// return;
+//
+// std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+// aFeature->data()->attribute(theAttribute));
+//
+// PartSet_Tools::setConstraints(aPreviewOp->sketch(), aFeature, theAttribute, aPoint->x(),
+// aPoint->y());
+//}
QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget* theParent,
- Config_WidgetAPI* theWidgetApi,
+ Config_WidgetAPI* theWidgetApi, std::string theParentId,
QList<ModuleBase_ModelWidget*>& theModelWidgets)
{
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+ XGUI_Workshop* aWorkshop = aConnector->workshop();
if (theType == "sketch-start-label") {
- PartSet_WidgetSketchLabel* aWgt = new PartSet_WidgetSketchLabel(theParent, theWidgetApi, "");
- aWgt->setOperationsMgr(xWorkshop()->operationMgr());
+ PartSet_WidgetSketchLabel* aWgt = new PartSet_WidgetSketchLabel(theParent, theWidgetApi, theParentId);
+ aWgt->setWorkshop(aWorkshop);
theModelWidgets.append(aWgt);
return aWgt->getControl();
- } else
- return 0;
-}
+ } else if (theType == "sketch-2dpoint_selector") {
+ PartSet_WidgetPoint2D* aWgt = new PartSet_WidgetPoint2D(theParent, theWidgetApi, theParentId);
+ aWgt->setWorkshop(aWorkshop);
+ aWgt->setSketch(myCurrentSketch);
+ connect(aWgt, SIGNAL(vertexSelected(ObjectPtr, const TopoDS_Shape&)),
+ this, SLOT(onVertexSelected(ObjectPtr, const TopoDS_Shape&)));
-XGUI_Workshop* PartSet_Module::xWorkshop() const
-{
- XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
- if (aConnector) {
- return aConnector->workshop();
- }
- return 0;
-}
-
-
-QIntList PartSet_Module::sketchSelectionModes(ObjectPtr theFeature)
-{
- QIntList aModes;
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature);
- if (aFeature) {
- if (aFeature->getKind() == SketchPlugin_Sketch::ID()) {
- aModes.append(TopAbs_FACE);
- return aModes;
- } else if (PartSet_Tools::isConstraintFeature(aFeature->getKind())) {
- aModes.append(AIS_DSM_Text);
- aModes.append(AIS_DSM_Line);
- return aModes;
- }
- }
- aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_VERTEX));
- aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_EDGE));
- return aModes;
-}
-
+ theModelWidgets.append(aWgt);
+ return aWgt->getControl();
+ } if (theType == "point2ddistance") {
+ PartSet_WidgetPoint2dDistance* aWgt = new PartSet_WidgetPoint2dDistance(theParent, theWidgetApi, theParentId);
+ aWgt->setWorkshop(aWorkshop);
+ aWgt->setSketch(myCurrentSketch);
-gp_Pln PartSet_Module::getSketchPlane(FeaturePtr theSketch) const
-{
- DataPtr aData = theSketch->data();
- std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
- aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
- std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- aData->attribute(SketchPlugin_Sketch::NORM_ID()));
- gp_Pnt aOrig(anOrigin->x(), anOrigin->y(), anOrigin->z());
- gp_Dir aDir(aNorm->x(), aNorm->y(), aNorm->z());
- return gp_Pln(aOrig, aDir);
+ theModelWidgets.append(aWgt);
+ return aWgt->getControl();
+ }else
+ return 0;
}
-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) {
- // do not perform commit of the current edit operation here, because
- // this functionality is realized inside this operation
- /*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);
- }
- }
-}
+//XGUI_Workshop* PartSet_Module::xWorkshop() const
+//{
+// XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+// if (aConnector) {
+// return aConnector->workshop();
+// }
+// return 0;
+//}
+
+
+//QIntList PartSet_Module::sketchSelectionModes(ObjectPtr theFeature)
+//{
+// QIntList aModes;
+// FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature);
+// if (aFeature) {
+// if (aFeature->getKind() == SketchPlugin_Sketch::ID()) {
+// aModes.append(TopAbs_FACE);
+// return aModes;
+// } else if (PartSet_Tools::isConstraintFeature(aFeature->getKind())) {
+// aModes.append(AIS_DSM_Text);
+// aModes.append(AIS_DSM_Line);
+// return aModes;
+// }
+// }
+// aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_VERTEX));
+// aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_EDGE));
+// return aModes;
+//}
+
+
+//gp_Pln PartSet_Module::getSketchPlane(FeaturePtr theSketch) const
+//{
+// DataPtr aData = theSketch->data();
+// std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
+// aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
+// std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+// aData->attribute(SketchPlugin_Sketch::NORM_ID()));
+// gp_Pnt aOrig(anOrigin->x(), anOrigin->y(), anOrigin->z());
+// gp_Dir aDir(aNorm->x(), aNorm->y(), aNorm->z());
+// 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) {
+// // do not perform commit of the current edit operation here, because
+// // this functionality is realized inside this operation
+// /*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 <ModuleBase_ViewerFilters.h>
#include <XGUI_Command.h>
#include <ModelAPI_Feature.h>
+#include <ModelAPI_CompositeFeature.h>
+
#include <StdSelect_FaceFilter.hxx>
+#include <TopoDS_Shape.hxx>
#include <QMap>
#include <QObject>
#include <memory>
-class PartSet_Listener;
-class ModelAPI_Feature;
-class XGUI_ViewerPrs;
-class XGUI_Workshop;
class ModuleBase_Operation;
-class GeomAPI_AISObject;
+class ModuleBase_IViewWindow;
class PARTSET_EXPORT PartSet_Module : public ModuleBase_IModule
{
virtual ~PartSet_Module();
/// Reads description of features from XML file
- virtual void createFeatures();
+ //virtual void createFeatures();
/// Called on creation of menu item in desktop
- virtual void featureCreated(QAction* theFeature);
+ //virtual void featureCreated(QAction* theFeature);
- std::string featureFile(const std::string&);
+ //std::string featureFile(const std::string&);
/// Creates an operation and send it to loop
/// \param theCmdId the operation name
/// Updates current operation preview, if it has it.
/// \param theCmdId the operation name
- void updateCurrentPreview(const std::string& theCmdId);
+ //void updateCurrentPreview(const std::string& theCmdId);
/// Creates custom widgets for property panel
virtual QWidget* createWidgetByType(const std::string& theType, QWidget* theParent,
- Config_WidgetAPI* theWidgetApi,
+ Config_WidgetAPI* theWidgetApi, std::string theParentId,
QList<ModuleBase_ModelWidget*>& theModelWidgets);
- XGUI_Workshop* xWorkshop() const;
+ //XGUI_Workshop* xWorkshop() const;
/// Returns list of selection modes for the given object for sketch operation
- static QIntList sketchSelectionModes(ObjectPtr theFeature);
+ //static QIntList sketchSelectionModes(ObjectPtr theFeature);
+
+ /// Call back forlast tuning of property panel before operation performance
+ virtual void propertyPanelDefined(ModuleBase_Operation* theOperation);
+
+ QStringList sketchOperationIdList() const;
public slots:
- void onFeatureTriggered();
+ //void onFeatureTriggered();
/// SLOT, that is called after the operation is started. Connect on the focus activated signal
- void onOperationStarted(ModuleBase_Operation* theOperation);
+ //void onOperationStarted(ModuleBase_Operation* theOperation);
/// SLOT, that is called after the operation is stopped. Switched off the modfications performed
/// by the operation start
- void onOperationStopped(ModuleBase_Operation* theOperation);
+ //void onOperationStopped(ModuleBase_Operation* theOperation);
/// SLOT, that is called afetr the popup menu action clicked.
- void onContextMenuCommand(const QString& theId, bool isChecked);
+ //void onContextMenuCommand(const QString& theId, bool isChecked);
/// SLOT, to apply to the current viewer the operation
/// \param theX the X projection value
/// \param theY the Y projection value
/// \param theZ the Z projection value
- void onPlaneSelected(double theX, double theY, double theZ);
+ //void onPlaneSelected(double theX, double theY, double theZ);
/// SLOT, to fit all current viewer
- void onFitAllView();
+ //void onFitAllView();
- void onRestartOperation(std::string theName, ObjectPtr theFeature);
+ //void onRestartOperation(std::string theName, ObjectPtr theFeature);
/// SLOT, to switch on/off the multi selection in the viewer
/// \param theEnabled the enabled state
- void onMultiSelectionEnabled(bool theEnabled);
+ //void onMultiSelectionEnabled(bool theEnabled);
/// SLOT, to stop or start selection mode for the features
/// \param theFeatures a list of features to be disabled
/// \param theToStop the boolean state whether it it stopped or non stopped
- void onStopSelection(const QList<ObjectPtr>& theFeatures, const bool isStop);
+ //void onStopSelection(const QList<ObjectPtr>& theFeatures, const bool isStop);
/// SLOT, to set selection
/// \param theFeatures a list of features to be selected
- void onSetSelection(const QList<ObjectPtr>& theFeatures);
+ //void onSetSelection(const QList<ObjectPtr>& theFeatures);
/// SLOT, Defines Sketch editing mode
/// \param thePln - plane of current sketch
- void setSketchingMode(const gp_Pln& thePln);
+ //void setSketchingMode(const gp_Pln& thePln);
/// SLOT, to visualize the feature in another local context mode
/// \param theFeature the feature to be put in another local context mode
/// \param theMode the mode appeared on the feature
- void onFeatureConstructed(ObjectPtr theFeature, int theMode);
+ //void onFeatureConstructed(ObjectPtr theFeature, int theMode);
/// Slot which reacts to the point 2d set to the feature. Creates a constraint
/// \param the feature
/// \param the attribute of the feature
- void onStorePoint2D(ObjectPtr theFeature, const std::string& theAttribute);
+ //void onStorePoint2D(ObjectPtr theFeature, const std::string& theAttribute);
/// Called when sketch is launched
- void onSketchLaunched();
+ //void onSketchLaunched();
protected slots:
- /// Called on selection changed event
+ /// Called when previous operation is finished
+ virtual void onOperationComitted(ModuleBase_Operation* theOperation);
+
+ virtual void onOperationAborted(ModuleBase_Operation* theOperation);
+
+ virtual void onOperationStarted(ModuleBase_Operation* theOperation);
+
+ virtual void onOperationStopped(ModuleBase_Operation* theOperation);
+
+ /// Called when previous operation is finished
virtual void onSelectionChanged();
+ /// 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);
+ void onMousePressed(ModuleBase_IViewWindow* theWnd, 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);
+ virtual void onMouseReleased(ModuleBase_IViewWindow* theWnd, 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);
+ virtual void onMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
/// SLOT, that is called by the mouse double click in the viewer.
/// \param theEvent the mouse event
- virtual void onMouseDoubleClick(QMouseEvent* theEvent);
+ //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);
+ //virtual void onKeyRelease(QKeyEvent* theEvent);
+
+ /// Launches the operation from current highlighting
+ void launchEditing();
protected:
- /// Creates a new operation
- /// \param theCmdId the operation name
- /// \param theFeatureKind a kind of feature to get the feature xml description
- ModuleBase_Operation* createOperation(const std::string& theCmdId,
- const std::string& theFeatureKind = "");
+ /// Register validators for this module
+ virtual void registerValidators();
+ /// Returns new instance of operation object (used in createOperation for customization)
+ //virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);
- protected:
//! Edits the feature
- void editFeature(FeaturePtr theFeature);
+ //void editFeature(FeaturePtr theFeature);
- gp_Pln getSketchPlane(FeaturePtr theSketch) const;
+ //gp_Pln getSketchPlane(FeaturePtr theSketch) const;
+
+ private slots:
+ void onVertexSelected(ObjectPtr theObject, const TopoDS_Shape& theShape);
private:
+ /// Converts mouse position to 2d coordinates.
+ /// Member myCurrentSketch has to be correctly defined
+ void get2dPoint(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent,
+ double& theX, double& theY);
+
+ /// Breaks sequense of automatically resterted operations
+ void breakOperationSequence();
+
//XGUI_Workshop* myWorkshop;
- PartSet_Listener* myListener;
+ //PartSet_Listener* myListener;
+
+ //std::map<std::string, std::string> myFeaturesInFiles;
+
+ //Handle(StdSelect_FaceFilter) myPlaneFilter;
+ //Handle(ModuleBase_ShapeInPlaneFilter) mySketchFilter;
+ QString myLastOperationId;
+ FeaturePtr myLastFeature;
+
+ bool myIsDragging;
+ bool myDragDone;
- std::map<std::string, std::string> myFeaturesInFiles;
+ // Automatical restarting mode flag
+ bool myRestartingMode;
- Handle(StdSelect_FaceFilter) myPlaneFilter;
- Handle(ModuleBase_ShapeInPlaneFilter) mySketchFilter;
+ double myCurX, myCurY;
+ CompositeFeaturePtr myCurrentSketch;
+ QList<FeaturePtr> myEditingFeatures;
};
#endif
--- /dev/null
+// File: PartSet_Operation.cpp
+// Created: 24 Nov 2014
+// Author: Vitaly SMETANNIKOV
+
+#include "PartSet_Operation.h"
+
+#include <ModuleBase_IWorkshop.h>
+#include <ModuleBase_ISelection.h>
+
+void PartSet_Operation::onSelectionChanged()
+{
+ if (isEditOperation()) {
+ ModuleBase_ISelection* aSelection = myWorkshop->selection();
+ QList<ModuleBase_ViewerPrs> aHighlighted = aSelection->getHighlighted();
+ QList<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
+ }
+}
\ No newline at end of file
--- /dev/null
+// File: PartSet_Operation.h
+// Created: 24 Nov 2014
+// Author: Vitaly SMETANNIKOV
+
+#ifndef PartSet_Operation_H
+#define PartSet_Operation_H
+
+#include "PartSet.h"
+
+#include <ModuleBase_Operation.h>
+
+class ModuleBase_IWorkshop;
+
+class PARTSET_EXPORT PartSet_Operation : public ModuleBase_Operation
+{
+Q_OBJECT
+ public:
+ PartSet_Operation(const QString& theId = "", QObject* theParent = 0)
+ :ModuleBase_Operation(theId, theParent) {}
+
+ void setWorkshop(ModuleBase_IWorkshop* theWorkshop) { myWorkshop = theWorkshop; }
+
+public slots:
+ void onSelectionChanged();
+
+private:
+ ModuleBase_IWorkshop* myWorkshop;
+};
+
+#endif
\ No newline at end of file
+++ /dev/null
-// File: PartSet_OperationFeatureBase.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_OperationFeatureBase.h>
-
-#include <PartSet_Tools.h>
-#include <PartSet_OperationSketch.h>
-
-#include <SketchPlugin_Feature.h>
-#include <SketchPlugin_Point.h>
-#include <SketchPlugin_Line.h>
-#include <SketchPlugin_Circle.h>
-#include <SketchPlugin_Arc.h>
-#include <SketchPlugin_ConstraintDistance.h>
-#include <SketchPlugin_ConstraintLength.h>
-#include <SketchPlugin_ConstraintRadius.h>
-#include <SketchPlugin_ConstraintParallel.h>
-#include <SketchPlugin_ConstraintPerpendicular.h>
-#include <SketchPlugin_ConstraintCoincidence.h>
-
-#include <GeomAPI_Pnt2d.h>
-
-#include <ModuleBase_OperationDescription.h>
-#include <ModuleBase_WidgetPoint2D.h>
-#include <ModuleBase_WidgetValueFeature.h>
-#include "ModuleBase_IPropertyPanel.h"
-#include "ModuleBase_ISelection.h"
-#include "ModuleBase_IViewer.h"
-
-#include <XGUI_Constants.h>
-
-#include <V3d_View.hxx>
-#include <BRep_Tool.hxx>
-
-#ifdef _DEBUG
-#include <QDebug>
-#include <iostream>
-#endif
-
-#include <QMouseEvent>
-
-using namespace std;
-
-PartSet_OperationFeatureBase::PartSet_OperationFeatureBase(const QString& theId,
- QObject* theParent,
- CompositeFeaturePtr theFeature)
- : PartSet_OperationSketchBase(theId, theParent),
- mySketch(theFeature)
-{
-}
-
-PartSet_OperationFeatureBase::~PartSet_OperationFeatureBase()
-{
-}
-
-CompositeFeaturePtr PartSet_OperationFeatureBase::sketch() const
-{
- return mySketch;
-}
-
-void PartSet_OperationFeatureBase::mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection)
-{
- 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 (aSelected.empty()) {
- PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
- } else {
- ModuleBase_ViewerPrs aPrs = aSelected.first();
- if (getViewerPoint(aPrs, theViewer, aX, anY)) {
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- PartSet_Tools::setConstraints(sketch(), feature(), aActiveWgt->attributeID(), aX, anY);
- }
- const TopoDS_Shape& aShape = aPrs.shape();
- if (!aShape.IsNull() && aShape.ShapeType() == TopAbs_EDGE) { // a line is selected
- PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
- }
- }
- ObjectPtr aFeature;
- if (!aSelected.empty()) {
- ModuleBase_ViewerPrs aPrs = aSelected.first();
- aFeature = aPrs.object();
- } else {
- aFeature = feature(); // for the widget distance only
- }
-
- bool isApplyed = setWidgetValue(aFeature, aX, anY);
- if (isApplyed) {
- flushUpdated();
- myPropertyPanel->activateNextWidget();
- }
- // the operation can be committed only when there is no an active widget anymore
- // if this check is absent, the edit operation for constraint perpendicular is stopped
- // after the first object selection in the viewer(there are two objects to be selected)
- // the second case is the constraint distance, the edit is stopped after any mouse click
- // in the viewer whenever it is applyed or not to the selection control
- if (!myPropertyPanel->activeWidget())
- commit();
-}
-
-bool PartSet_OperationFeatureBase::getViewerPoint(ModuleBase_ViewerPrs thePrs,
- ModuleBase_IViewer* theViewer,
- double& theX, double& theY)
-{
- return PartSet_Tools::hasVertexShape(thePrs, sketch(), theViewer->activeView(),
- theX, theY);
-}
-
-/*bool PartSet_OperationFeatureBase::setWidgetValue(ObjectPtr theFeature, double theX, double theY)
-{
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- if (!aActiveWgt)
- return false;
- ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
- aValue->setObject(theFeature);
- aValue->setPoint(std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY)));
- bool isApplyed = aActiveWgt->setValue(aValue);
-
- delete aValue;
- myIsModified = (myIsModified || isApplyed);
- return isApplyed;
-}*/
+++ /dev/null
-// File: PartSet_OperationFeatureBase.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PARTSET_OPERATIONFEATUREBASE_H
-#define PARTSET_OPERATIONFEATUREBASE_H
-
-#include "PartSet.h"
-
-#include <PartSet_OperationSketchBase.h>
-#include <PartSet_Constants.h>
-
-#include <QObject>
-
-class GeomDataAPI_Point2D;
-class QMouseEvent;
-class QKeyEvent;
-
-/*!
- \class PartSet_OperationFeatureBase
- * \brief The operation for the sketch feature creation
- */
-class PARTSET_EXPORT PartSet_OperationFeatureBase : public PartSet_OperationSketchBase
-{
-Q_OBJECT
-
- public:
- /// Constructor
- /// \param theId the feature identifier
- /// \param theParent the operation parent
- /// \param theSketch the parent feature
- PartSet_OperationFeatureBase(const QString& theId, QObject* theParent, CompositeFeaturePtr theSketch);
- /// Destructor
- virtual ~PartSet_OperationFeatureBase();
-
- /// Returns the operation sketch feature
- /// \returns the sketch instance
- virtual CompositeFeaturePtr sketch() const;
-
- /// 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, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection);
-
- protected:
- /// Return a widget value point by the selection and the viewer position
- /// \param thePrs the presentation
- /// \param theViewer a viewer to have the viewer the eye position
- /// \param theX the horizontal coordinate
- /// \param theY the vertical coordinate
- /// \return true if the point exits in the selection
- virtual bool getViewerPoint(ModuleBase_ViewerPrs thePrs,
- ModuleBase_IViewer* theViewer,
- double& theX, double& theY);
-
- protected:
- CompositeFeaturePtr mySketch; ///< the sketch of the feature
-};
-
-#endif
+++ /dev/null
-// File: PartSet_OperationFeatureCreate.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_OperationFeatureCreate.h>
-
-#include <PartSet_Tools.h>
-#include <PartSet_OperationSketch.h>
-
-#include <SketchPlugin_Feature.h>
-#include <SketchPlugin_Point.h>
-#include <SketchPlugin_Line.h>
-#include <SketchPlugin_Circle.h>
-#include <SketchPlugin_Arc.h>
-#include <SketchPlugin_ConstraintDistance.h>
-#include <SketchPlugin_ConstraintLength.h>
-#include <SketchPlugin_ConstraintRadius.h>
-#include <SketchPlugin_ConstraintParallel.h>
-#include <SketchPlugin_ConstraintPerpendicular.h>
-#include <SketchPlugin_ConstraintCoincidence.h>
-#include <SketchPlugin_ConstraintRigid.h>
-
-#include <GeomAPI_Pnt2d.h>
-
-#include <ModuleBase_OperationDescription.h>
-#include <ModuleBase_WidgetPoint2D.h>
-#include <ModuleBase_WidgetValueFeature.h>
-#include <ModuleBase_ViewerPrs.h>
-#include <ModuleBase_IPropertyPanel.h>
-#include <ModuleBase_ISelection.h>
-#include <ModuleBase_IViewer.h>
-
-#include <XGUI_Constants.h>
-
-#include <V3d_View.hxx>
-
-#ifdef _DEBUG
-#include <QDebug>
-#include <iostream>
-#endif
-
-#include <QMouseEvent>
-
-using namespace std;
-
-PartSet_OperationFeatureCreate::PartSet_OperationFeatureCreate(const QString& theId,
- QObject* theParent,
- CompositeFeaturePtr theFeature)
- : PartSet_OperationFeatureBase(theId, theParent, theFeature)
-{
-}
-
-PartSet_OperationFeatureCreate::~PartSet_OperationFeatureCreate()
-{
-}
-
-bool PartSet_OperationFeatureCreate::canProcessKind(const std::string& theId)
-{
- return theId == SketchPlugin_Line::ID() || theId == SketchPlugin_Point::ID()
- || theId == SketchPlugin_Circle::ID() || theId == SketchPlugin_Arc::ID()
- || theId == SketchPlugin_ConstraintDistance::ID()
- || theId == SketchPlugin_ConstraintLength::ID()
- || theId == SketchPlugin_ConstraintRadius::ID()
- || theId == SketchPlugin_ConstraintParallel::ID()
- || theId == SketchPlugin_ConstraintPerpendicular::ID()
- || theId == SketchPlugin_ConstraintCoincidence::ID()
- || theId == SketchPlugin_ConstraintRigid::ID();
-}
-
-void PartSet_OperationFeatureCreate::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
-{
- double 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::keyReleased(const int theKey)
-{
- switch (theKey) {
- case Qt::Key_Return:
- case Qt::Key_Enter: {
- // it start a new line creation at a free point
- if(isValid())
- restartOperation(feature()->getKind());
- }
- break;
- default:
- break;
- }
-}
-
-void PartSet_OperationFeatureCreate::mouseReleased(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection)
-{
- 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;
-
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
-
- if (aSelected.empty()) {
- PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
- } else {
- ModuleBase_ViewerPrs aPrs = aSelected.first();
- if (getViewerPoint(aPrs, theViewer, aX, anY)) {
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- PartSet_Tools::setConstraints(sketch(), feature(), aActiveWgt->attributeID(), aX, anY);
- isClosedContour = true;
- }
- const TopoDS_Shape& aShape = aPrs.shape();
- if (!aShape.IsNull() && aShape.ShapeType() == TopAbs_EDGE) { // a line is selected
- ObjectPtr aObject = aPrs.object();
- if (sketch()->isSub(aObject))
- PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
- else {
- // we have to create the selected edge for the current sketch
- ResultPtr aRes = PartSet_Tools::createFixedObjectByEdge(aPrs, sketch());
- aSelected.first().setFeature(aRes);
- }
- }
- }
- ObjectPtr aFeature;
- if (!aSelected.empty()) {
- ModuleBase_ViewerPrs aPrs = aSelected.first();
- aFeature = aPrs.object();
- } else {
- aFeature = feature(); // for the widget distance only
- }
-
- bool isApplyed = setWidgetValue(aFeature, aX, anY);
- if (isApplyed) {
- flushUpdated();
- myPropertyPanel->activateNextWidget();
- }
-
- if (!myPropertyPanel->activeWidget()) {
- if(commit() && !isClosedContour) {
- // if the point creation is finished, the next mouse release should commit the modification
- // the next release can happens by double click in the viewer
- restartOperation(feature()->getKind(), feature());
- }
- }
-}
-
-void PartSet_OperationFeatureCreate::startOperation()
-{
- PartSet_OperationSketchBase::startOperation();
- //emit multiSelectionEnabled(false);
-}
-
-void PartSet_OperationFeatureCreate::abortOperation()
-{
- emit featureConstructed(feature(), FM_Hide);
- PartSet_OperationSketchBase::abortOperation();
-}
-
-void PartSet_OperationFeatureCreate::stopOperation()
-{
- PartSet_OperationSketchBase::stopOperation();
- //emit multiSelectionEnabled(true);
-}
-
-void PartSet_OperationFeatureCreate::afterCommitOperation()
-{
- PartSet_OperationSketchBase::afterCommitOperation();
- emit featureConstructed(feature(), FM_Deactivation);
-}
-
-FeaturePtr PartSet_OperationFeatureCreate::createFeature(const bool theFlushMessage,
- CompositeFeaturePtr theCompositeFeature)
-{
- FeaturePtr aNewFeature = ModuleBase_Operation::createFeature(false, sketch());
-
- if (theFlushMessage)
- flushCreated();
- return aNewFeature;
-}
-
-
-void PartSet_OperationFeatureCreate::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
-{
- PartSet_OperationFeatureBase::onWidgetActivated(theWidget);
- if (myInitFeature && theWidget) {
- ModuleBase_WidgetPoint2D* aWgt = dynamic_cast<ModuleBase_WidgetPoint2D*>(theWidget);
- if (aWgt && aWgt->initFromPrevious(myInitFeature)) {
- myInitFeature = FeaturePtr();
- if (myPropertyPanel)
- myPropertyPanel->activateNextWidget();
- }
- }
-}
+++ /dev/null
-// File: PartSet_OperationFeatureCreate.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_OperationFeatureCreate_H
-#define PartSet_OperationFeatureCreate_H
-
-#include "PartSet.h"
-
-#include <PartSet_OperationFeatureBase.h>
-#include <PartSet_Constants.h>
-
-#include <QObject>
-
-class GeomDataAPI_Point2D;
-class QMouseEvent;
-class QKeyEvent;
-
-/*!
- \class PartSet_OperationFeatureCreate
- * \brief The operation for the sketch feature creation
- */
-class PARTSET_EXPORT PartSet_OperationFeatureCreate : public PartSet_OperationFeatureBase
-{
-Q_OBJECT
-
- public:
- /// Returns true if the feature with the given kind can be created by this operation
- /// \param theId the feature kind
- /// \return the boolean result
- static bool canProcessKind(const std::string& theId);
-
- /// Constructor
- /// \param theId the feature identifier
- /// \param theParent the operation parent
- /// \param theSketch the parent feature
- PartSet_OperationFeatureCreate(
- const QString& theId, QObject* theParent, CompositeFeaturePtr theSketch);
- /// Destructor
- virtual ~PartSet_OperationFeatureCreate();
-
- /// 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, 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, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection);
- /// Processes the key pressed in the view
- /// \param theKey a key value
- virtual void keyReleased(const int theKey);
-
- /// Initializes the operation with previously created feature. It is used in sequental operations
- void initFeature(FeaturePtr theFeature) { myInitFeature = theFeature; }
-
- public slots:
- /// Slots which listen the mode widget activation
- /// \param theWidget the model widget
- virtual void onWidgetActivated(ModuleBase_ModelWidget* theWidget);
-
- protected:
- /// \brief Virtual method called when operation is started
- /// Virtual method called when operation started (see start() method for more description)
- /// After the parent operation body perform, set sketch feature to the created line feature
- virtual void startOperation();
-
- /// Virtual method called when operation aborted (see abort() method for more description)
- /// Before the feature is aborted, it should be hidden from the viewer
- virtual void abortOperation();
-
- /// Virtual method called when operation stopped - committed or aborted.
- /// Restore the multi selection state
- virtual void stopOperation();
-
- /// Virtual method called after operation committed (see commit() method for more description)
- virtual void afterCommitOperation();
-
- /// Creates an operation new feature
- /// In addition to the default realization it appends the created line feature to
- /// the sketch feature
- /// \param theFlushMessage the flag whether the create message should be flushed
- /// \returns the created feature
- virtual FeaturePtr createFeature(const bool theFlushMessage = true,
- CompositeFeaturePtr theCompositeFeature = CompositeFeaturePtr());
-
-protected:
- /// Feature of previous operation (for sequintal operations)
- FeaturePtr myInitFeature;
-};
-
-#endif
+++ /dev/null
-// File: PartSet_OperationFeatureEdit.h
-// Created: 05 May 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_OperationFeatureEdit.h>
-#include <PartSet_Tools.h>
-#include <PartSet_OperationSketch.h>
-#include <SketchPlugin_Constraint.h>
-
-#include <ModuleBase_OperationDescription.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>
-
-#include <SketchPlugin_Feature.h>
-#include <GeomDataAPI_Point2D.h>
-
-#include <ModelAPI_Data.h>
-#include <ModelAPI_Document.h>
-#include <ModelAPI_Events.h>
-
-#include <Events_Loop.h>
-
-#include <SketchPlugin_Line.h>
-
-#include <V3d_View.hxx>
-#include <AIS_DimensionOwner.hxx>
-#include <AIS_DimensionSelectionMode.hxx>
-
-#ifdef _DEBUG
-#include <QDebug>
-#endif
-
-#include <QMouseEvent>
-
-using namespace std;
-
-PartSet_OperationFeatureEdit::PartSet_OperationFeatureEdit(const QString& theId,
- QObject* theParent,
- CompositeFeaturePtr theFeature)
- : PartSet_OperationFeatureBase(theId, theParent, theFeature),
- myIsBlockedSelection(false), myIsBlockedByDoubleClick(false)
-{
- myIsEditing = true;
-}
-
-PartSet_OperationFeatureEdit::~PartSet_OperationFeatureEdit()
-{
-}
-
-void PartSet_OperationFeatureEdit::initSelection(ModuleBase_ISelection* theSelection,
- ModuleBase_IViewer* theViewer)
-{
- // the method of the parent should is useless here because it processes the given
- // selection in different way
- //PartSet_OperationFeatureBase::initSelection(theSelection, theViewer);
-
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
-
- // there is a bug in OCC, where the highlighted objects are repeated and should be
- // filtered on the unique state here
- QList<ModuleBase_ViewerPrs> anUniqueHighlighted;
- foreach (ModuleBase_ViewerPrs aPrs, aHighlighted) {
- if (!PartSet_Tools::isContainPresentation(anUniqueHighlighted, aPrs))
- anUniqueHighlighted.append(aPrs);
- }
- fillFeature2Attribute(anUniqueHighlighted, theViewer, myHighlightedFeature2Attribute);
-
- foreach (ModuleBase_ViewerPrs aPrs, anUniqueHighlighted) {
- if (!PartSet_Tools::isContainPresentation(aSelected, aPrs))
- aSelected.append(aPrs);
- }
- fillFeature2Attribute(aSelected, theViewer, myAllFeature2Attribute);
-}
-
-void PartSet_OperationFeatureEdit::fillFeature2Attribute(
- const QList<ModuleBase_ViewerPrs>& thePresentations,
- ModuleBase_IViewer* theViewer,
- std::map<FeaturePtr, std::list<std::string> >& theFeature2Attribute)
-{
- // 1. find all features with skipping features with selected vertex shapes
- theFeature2Attribute.clear();
- // firstly, collect the features without local selection
- double aX, anY;
- foreach (ModuleBase_ViewerPrs aPrs, thePresentations) {
- if (getViewerPoint(aPrs, theViewer, aX, anY))
- continue;
- else {
- ObjectPtr aObject = aPrs.object();
- if (!aObject)
- continue;
- FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
- if (aFeature && theFeature2Attribute.find(aFeature) == theFeature2Attribute.end()) {
- std::list<std::string> aList;
- // using an empty list as a sign, that this feature should be moved itself
- theFeature2Attribute[aFeature] = aList;
- }
- }
- }
- // 2. collect the features with a local selection on them.
- // if the list already has this feature, the local selection is skipped
- // that means that if the selection contains a feature and a feature with local selected point,
- // the edit is performed for a full feature
- foreach (ModuleBase_ViewerPrs aPrs, thePresentations) {
- if (getViewerPoint(aPrs, theViewer, aX, anY)) {
- ObjectPtr aObject = aPrs.object();
- if (!aObject)
- continue;
- FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
- if (!aFeature)
- continue;
-
- // append the attribute of the vertex if it is found on the current feature
- std::shared_ptr<GeomDataAPI_Point2D> aPoint2D = PartSet_Tools::getFeaturePoint(
- aFeature, aX, anY);
- std::string anAttribute = aFeature->data()->id(aPoint2D);
- std::list<std::string> aList;
- if (theFeature2Attribute.find(aFeature) != theFeature2Attribute.end())
- aList = theFeature2Attribute[aFeature];
-
- aList.push_back(anAttribute);
- theFeature2Attribute[aFeature] = aList;
- }
- }
-}
-
-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, theViewer, theSelection);
- // the current point should be cleared because it is saved from the previous move and
- // should be reinitialized after the start moving. It is important for example for the lenght
- // constraint where the first widget is a viewer selector.
- myCurPoint.clear();
- }
- else {
- // commit always until the selection restore is realized (for feature and local selection)
- // TODO: check whether the selection is changed and restart the operation only if it is modified
- commit();
- emitFeaturesDeactivation();
- // find nearest feature and restart the operation for it
- Handle(V3d_View) aView = theViewer->activeView();
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
-
- ObjectPtr aFeature = PartSet_Tools::nearestFeature(theEvent->pos(), aView, sketch(),
- aSelected, aHighlighted);
- if (aFeature) {
- restartOperation(PartSet_OperationFeatureEdit::Type(), aFeature);
- }
- }
- // the next code is commented because the new attempt to commit/restart operation implementation:
- //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 (!aSelected.empty()) {
- // aObject = aSelected.first().object();
- //} else {
- // if (!aHighlighted.empty())
- // aObject = aHighlighted.first().object();
- //}*/
- //// the priority to a highlighted object in order to edit it, even if the selected object is
- //// the feature of this operation. Otherwise, the highlighting is ignored and the selected
- //// object is moved
- //if (!aHighlighted.empty()) {
- // aObject = aHighlighted.front().object();
- //}
- //if (!aObject && !aSelected.empty()) // changed for a constrain
- // aObject = aSelected.front().object();
-
- //FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
- //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());
- // // }
- // // emit setSelection(aSelected);
- // //} else
- // if (aFeature) {
- // std::string anOperationType = PartSet_OperationFeatureEdit::Type();
- // restartOperation(anOperationType, aFeature);
- // }
- // //}
- // }
- //}
-}
-
-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);
-
- theViewer->enableSelection(false);
-
- //blockSelection(true);
- if (myCurPoint.myIsInitialized) {
- double aCurX, aCurY;
- PartSet_Tools::convertTo2D(myCurPoint.myPoint, sketch(), aView, aCurX, aCurY);
-
- double aX, anY;
- PartSet_Tools::convertTo2D(aPoint, sketch(), aView, aX, anY);
-
- double aDeltaX = aX - aCurX;
- double aDeltaY = anY - aCurY;
-
- // the next code is commented because it is obsolete by the multi edit operation realization here
- //if (myIsMultiOperation) {
- // std::map<FeaturePtr, std::list<std::string>>::iterator aFeatIter = myFeature2Attribute.begin();
- // while (aFeatIter != myFeature2Attribute.end()) {
- // FeaturePtr aFeature = aFeatIter->first;
- // std::list<std::string> anAttributes = aFeatIter->second;
- // // perform edit for the feature
- // if (anAttributes.empty()) {
- // std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
- // std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
- // if (aSketchFeature) {
- // aSketchFeature->move(aDeltaX, aDeltaY);
- // }
- // }
- // // perform edit for the feature's attribute
- // else {
- // std::list<std::string>::const_iterator anAttrIter = anAttributes.begin(),
- // anAttrEnd = anAttributes.end();
- // for (; anAttrIter != anAttrEnd; anAttrIter++) {
- // std::shared_ptr<GeomDataAPI_Point2D> aPointAttr = std::dynamic_pointer_cast<
- // GeomDataAPI_Point2D>(aFeature->data()->attribute(*anAttrIter));
- // if (aPointAttr) {
- // aPointAttr->move(aDeltaX, aDeltaY);
- // }
- // }
- // }
- // aFeatIter++;
- // }
- //}
- //else { // multieditoperation
-
- //std::shared_ptr<SketchPlugin_Feature> aSketchFeature = std::dynamic_pointer_cast<
- // SketchPlugin_Feature>(feature());
-
- bool isMoved = false;
- bool aHasShift = (theEvent->modifiers() & Qt::ShiftModifier);
-
- // the functionality to move the feature attribute if it exists in the internal map
- std::map<FeaturePtr, std::list<std::string>>::iterator aFeatIter, aFeatLast;
- if (aHasShift || myHighlightedFeature2Attribute.empty()) {
- aFeatIter = myAllFeature2Attribute.begin();
- aFeatLast = myAllFeature2Attribute.end();
- }
- else {
- aFeatIter = myHighlightedFeature2Attribute.begin();
- aFeatLast = myHighlightedFeature2Attribute.end();
- }
-
- while (aFeatIter != aFeatLast) {
- FeaturePtr aFeature = aFeatIter->first;
- // MPV: added condition because it could be external edge of some object, not sketch
- if (aFeature && !sketch()->isSub(aFeature)) {
- aFeatIter++;
- continue;
- }
-
- std::list<std::string> anAttributes = aFeatIter->second;
- // perform edit for the feature
- if (anAttributes.empty()) {
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
- std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
- if (aSketchFeature) {
- aSketchFeature->move(aDeltaX, aDeltaY);
- isMoved = true;
- }
- }
- // perform edit for the feature's attribute
- else {
- std::list<std::string>::const_iterator anAttrIter = anAttributes.begin(),
- anAttrEnd = anAttributes.end();
- for (; anAttrIter != anAttrEnd; anAttrIter++) {
- std::shared_ptr<GeomDataAPI_Point2D> aPointAttr = std::dynamic_pointer_cast<
- GeomDataAPI_Point2D>(aFeature->data()->attribute(*anAttrIter));
- if (aPointAttr) {
- aPointAttr->move(aDeltaX, aDeltaY);
- isMoved = true;
- }
- }
- }
- aFeatIter++;
- }
- // the next code is commented because it is obsolete by the multi edit operation realization here
- // the feature is moved only if there is no a local selection on this feature
- //if (!isMoved) {
- // // MPV: added condition because it could be external edge of some object, not sketch
- // if (aSketchFeature && sketch()->isSub(aSketchFeature)) {
- // aSketchFeature->move(aDeltaX, aDeltaY);
- // static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY);
- // ModelAPI_EventCreator::get()->sendUpdated(feature(), anEvent);
- // }
- // }
- //} // multieditoperation
- sendFeatures(aHasShift);
- }
-
- myCurPoint.setPoint(aPoint);
-}
-
-void PartSet_OperationFeatureEdit::mouseReleased(
- QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection)
-{
- // the block is processed in order to do not commit the transaction until the started
- // double click functionality is performed. It is reproduced on Linux only
- if (myIsBlockedByDoubleClick)
- return;
-
- theViewer->enableSelection(true);
- // the next code is commented because it is obsolete by the multi edit operation realization here
- //if (myIsMultiOperation) {
- // if (commit()) {
- // std::map<FeaturePtr, std::list<std::string>>::iterator aFeatIter = myFeature2Attribute.begin();
- // while (aFeatIter != myFeature2Attribute.end()) {
- // FeaturePtr aFeature = aFeatIter->first;
- // if (aFeature) {
- // emit featureConstructed(aFeature, FM_Deactivation);
- // }
- // aFeatIter++;
- // }
- // }
- //}
- //else { // multieditoperation
- 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, theViewer, theSelection);
- //}// else {
- ////blockSelection(false);
- ////}
- //} // multieditoperation
- }
- else {
- theViewer->enableSelection(true);
-
- // commit operation if there is no selected an highlighted objects anymore
- Handle(V3d_View) aView = theViewer->activeView();
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
-
- if (aSelected.empty() && aHighlighted.empty()) {
- commit();
- emitFeaturesDeactivation();
- }
- else if (aSelected.size() == 1) {
- /// 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
- ObjectPtr anObject = aSelected.first().object();
- FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
- if (aFeature && PartSet_Tools::isConstraintFeature(aFeature->getKind()) &&
- aFeature != feature()) {
- restartOperation(PartSet_OperationFeatureEdit::Type(), aFeature);
- }
- }
- }
-}
-
-void PartSet_OperationFeatureEdit::mouseDoubleClick(
- QMouseEvent* theEvent, Handle_V3d_View theView,
- ModuleBase_ISelection* theSelection)
-{
- // TODO the functionality is important only for constraint feature. Should be moved in another place
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- // in case when the double click happens on another constraint feature when selection control is active
- // we should not perform the double click functionality
- // if there is no the viewer selector widget active, the operation is restarted with a correct feature
- ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
- if(aActiveWgt && aActiveWgt->isViewerSelector()) {
- if (!aSelected.empty()) {
- if (aSelected.size() == 1) {
- /// 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
- ObjectPtr anObject = aSelected.first().object();
- FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
- if (aFeature && PartSet_Tools::isConstraintFeature(aFeature->getKind()) &&
- aFeature != feature()) {
- return;
- }
- }
- }
- }
-
- myIsBlockedByDoubleClick = true;
- if (!aSelected.empty()) {
- ModuleBase_ViewerPrs aFeaturePrs = aSelected.first();
- if (!aFeaturePrs.owner().IsNull()) {
- Handle(AIS_DimensionOwner) anOwner = Handle(AIS_DimensionOwner)::DownCast(
- aFeaturePrs.owner());
- if (!anOwner.IsNull() && anOwner->SelectionMode() == AIS_DSM_Text) {
- bool isValid;
- double aValue = PartSet_Tools::featureValue(feature(), SketchPlugin_Constraint::VALUE(),
- isValid);
- if (isValid) {
- ModuleBase_WidgetEditor::editFeatureValue(feature(), SketchPlugin_Constraint::VALUE());
- flushUpdated();
- }
- }
- }
- }
- myIsBlockedByDoubleClick = false;
-}
-
-void PartSet_OperationFeatureEdit::startOperation()
-{
- PartSet_OperationSketchBase::startOperation();
- //emit multiSelectionEnabled(false);
-
- myCurPoint.clear();
-}
-
-void PartSet_OperationFeatureEdit::stopOperation()
-{
- //emit multiSelectionEnabled(true);
-
- //blockSelection(false, false);
-
- myHighlightedFeature2Attribute.clear();
- myAllFeature2Attribute.clear();
-}
-
-//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)
-{
- // do nothing in order to do not create a new feature
- return FeaturePtr();
-}
-
-void PartSet_OperationFeatureEdit::sendFeatures(const bool theIsAllFeatures)
-{
- static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_MOVED);
-
- std::map<FeaturePtr, std::list<std::string>>::iterator aFeatIter, aFeatLast;
- if (theIsAllFeatures || myHighlightedFeature2Attribute.empty()) {
- aFeatIter = myAllFeature2Attribute.begin();
- aFeatLast = myAllFeature2Attribute.end();
- }
- else {
- aFeatIter = myHighlightedFeature2Attribute.begin();
- aFeatLast = myHighlightedFeature2Attribute.end();
- }
- while (aFeatIter != aFeatLast) {
- FeaturePtr aFeature = aFeatIter->first;
- if (aFeature) {
- ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent);
- }
- aFeatIter++;
- }
-
- Events_Loop::loop()->flush(anEvent);
- flushUpdated();
-}
-
-void PartSet_OperationFeatureEdit::emitFeaturesDeactivation()
-{
- std::map<FeaturePtr, std::list<std::string>>::iterator aFeatIter = myAllFeature2Attribute.begin();
- while (aFeatIter != myAllFeature2Attribute.end()) {
- FeaturePtr aFeature = aFeatIter->first;
- if (aFeature) {
- emit featureConstructed(aFeature, FM_Deactivation);
- }
- aFeatIter++;
- }
-}
-
+++ /dev/null
-// File: PartSet_OperationFeatureEdit.h
-// Created: 05 May 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_OperationFeatureEdit_H
-#define PartSet_OperationFeatureEdit_H
-
-#include "PartSet.h"
-
-#include <PartSet_OperationFeatureBase.h>
-#include <QObject>
-
-class QMouseEvent;
-class ModuleBase_ISelection;
-
-/*!
- \class PartSet_OperationFeatureEdit
- * \brief The operation for the sketch feature creation
- */
-class PARTSET_EXPORT PartSet_OperationFeatureEdit : public PartSet_OperationFeatureBase
-{
-Q_OBJECT
- /// Struct to define gp point, with the state is the point is initialized
- struct Point
- {
- /// Constructor
- Point()
- {
- myIsInitialized = false;
- }
- /// Constructor
- /// \param thePoint the point
- Point(gp_Pnt thePoint)
- {
- setPoint(thePoint);
- }
- ~Point()
- {
- }
-
- /// clear the initialized flag.
- void clear()
- {
- myIsInitialized = false;
- }
- /// set the point and switch on the initialized flag
- /// \param thePoint the point
- void setPoint(const gp_Pnt& thePoint)
- {
- myIsInitialized = true;
- myPoint = thePoint;
- }
-
- bool myIsInitialized; /// the state whether the point is set
- gp_Pnt myPoint; /// the point
- };
-
- public:
- /// Returns the operation type key
- static std::string Type()
- {
- return "EditLine";
- }
-
- public:
- /// Constructor
- /// \param theId the feature identifier
- /// \param theParent the operation parent
- /// \param theFeature the parent feature
- PartSet_OperationFeatureEdit(const QString& theId, QObject* theParent, CompositeFeaturePtr theFeature);
- /// Destructor
- virtual ~PartSet_OperationFeatureEdit();
-
-
- /// Initialisation of operation with preliminary selection
- /// \param theSelected the list of selected presentations
- /// \param theHighlighted the list of highlighted presentations
- /// \param theViewer a viewer to have the viewer the eye position
- virtual void initSelection(ModuleBase_ISelection* theSelection,
- ModuleBase_IViewer* theViewer);
-
- /// Processes the mouse pressed 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 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, 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, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection);
-
- /// Processes the mouse double click 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 mouseDoubleClick(QMouseEvent* theEvent, Handle_V3d_View theView,
- ModuleBase_ISelection* theSelection);
-
- protected:
- /// \brief Virtual method called when operation is started
- /// Virtual method called when operation started (see start() method for more description)
- /// Switch off the multi selection state
- virtual void startOperation();
-
- /// Virtual method called when operation stopped - committed or aborted.
- /// Restore the multi selection state
- virtual void stopOperation();
-
- /// Creates an operation new feature
- /// Returns NULL feature. This is an operation of edition, not creation.
- /// \param theFlushMessage the flag whether the create message should be flushed
- /// \returns the created feature
- virtual FeaturePtr createFeature(const bool theFlushMessage = true,
- CompositeFeaturePtr theCompositeFeature = CompositeFeaturePtr());
-
- protected:
- void fillFeature2Attribute(const QList<ModuleBase_ViewerPrs>& thePresentations,
- ModuleBase_IViewer* theViewer,
- std::map<FeaturePtr, std::list<std::string> >& theFeature2Attribute);
-
- /// Emits a signal about the selection blocking. Emits a signal to change the selection.
- /// If the block is true, the signal clear selection, otherwise if restore selection flag allows,
- /// 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);
-
- /// Sends the features
- /// \param theIsAllFeatures a boolean value whether all features should be send or only the highlighted ones
- void sendFeatures(const bool theIsAllFeatures);
-
- /// Sends signal about the current features are to be deactivated
- void emitFeaturesDeactivation();
-
- private:
- // the next map should be removed when selection is processed in the move function
- std::map<FeaturePtr, std::list<std::string> > myHighlightedFeature2Attribute; /// a map of a feature to attributes
- std::map<FeaturePtr, std::list<std::string> > myAllFeature2Attribute; /// a map of a feature to attributes
-
- Point myCurPoint; ///< the current 3D point clicked or moved
- bool myIsBlockedSelection; ///< the state of the last state of selection blocked signal
- bool myIsBlockedByDoubleClick; ///< the block value by double click is processed to avoid
- ///< the mouse button release processing before the double click is finished
-};
-
-#endif
+++ /dev/null
-// File: PartSet_OperationSketch.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_OperationSketch.h>
-
-#include <PartSet_OperationFeatureEdit.h>
-#include <PartSet_Tools.h>
-
-#include <SketchPlugin_Sketch.h>
-#include <SketchPlugin_ConstraintLength.h>
-
-#include <ModelAPI_Data.h>
-#include <ModelAPI_AttributeDouble.h>
-#include <ModelAPI_AttributeRefList.h>
-#include <ModelAPI_Events.h>
-
-#include <GeomAlgoAPI_FaceBuilder.h>
-#include <GeomDataAPI_Point.h>
-#include <GeomDataAPI_Dir.h>
-#include <GeomAPI_XYZ.h>
-
-#include <ModuleBase_ViewerPrs.h>
-#include <ModuleBase_ISelection.h>
-#include <ModuleBase_IViewer.h>
-#include <Events_Loop.h>
-
-#include <AIS_Shape.hxx>
-#include <AIS_ListOfInteractive.hxx>
-#include <AIS_InteractiveObject.hxx>
-#include <AIS_DimensionOwner.hxx>
-#include <AIS_LengthDimension.hxx>
-#include <V3d_View.hxx>
-
-#ifdef _DEBUG
-#include <QDebug>
-#endif
-
-#include <QMouseEvent>
-
-using namespace std;
-
-PartSet_OperationSketch::PartSet_OperationSketch(const QString& theId, QObject* theParent)
- : PartSet_OperationSketchBase(theId, theParent)
-{
-}
-
-PartSet_OperationSketch::~PartSet_OperationSketch()
-{
-}
-
-CompositeFeaturePtr PartSet_OperationSketch::sketch() const
-{
- return std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(feature());
-}
-
-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);
- QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
- QList<ModuleBase_ViewerPrs> aHighlighted = theSelection->getHighlighted();
- // commented: the next code is commented because the nearestFeature check the highlighting
- // and selection inside
- //if (aHasShift && (aSelected.size() > 0)) {
- // foreach(ModuleBase_ViewerPrs aPrs, aHighlighted)
- // aSelected.append(aPrs);
- //}
- //if (aHasShift && aSelected.size() > 0)
- // return;
-
- // there should be a start of operation, which uses the pre-highlighted objects,
- // the selected ones are collected here and are processed by a mouse move
- //if (aHighlighted.size() == 1) {
- //if (aSelected.size() > 0) {
- // ObjectPtr aFeature = aSelected.first().object();
- // if (aFeature) {
- // commented: end
- Handle(V3d_View) aView = theViewer->activeView();
- ObjectPtr aFeature = PartSet_Tools::nearestFeature(theEvent->pos(), aView, feature(),
- aSelected, aHighlighted);
- if (aFeature)
- restartOperation(PartSet_OperationFeatureEdit::Type(), aFeature);
- //}
- //}
- //else
- // myFeatures = aHighlighted;
- //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
- TopoDS_Shape aShape = aPrs.shape();
- if (!aShape.IsNull()) {
- std::shared_ptr<GeomAPI_Dir> aDir = setSketchPlane(aShape);
- flushUpdated();
- emit featureConstructed(feature(), FM_Hide);
- // If selection is not a sketcher presentation then it has to be stored as
- // External shape
- if (feature() != aPrs.object()) {
- //std::shared_ptr<SketchPlugin_Sketch> aSketch =
- // std::dynamic_pointer_cast<SketchPlugin_Sketch>(feature());
- DataPtr aData = feature()->data();
- AttributeSelectionPtr aSelAttr =
- std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
- (aData->attribute(SketchPlugin_Feature::EXTERNAL_ID()));
- if (aSelAttr) {
- ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aPrs.object());
- if (aRes) {
- GeomShapePtr aShapePtr(new GeomAPI_Shape());
- aShapePtr->setImpl(new TopoDS_Shape(aShape));
- aSelAttr->setValue(aRes, aShapePtr);
- }
- }
- } else {
- // Turn viewer to the plane
- emit planeSelected(aDir->x(), aDir->y(), aDir->z());
- }
- emit updatePropPanel();
- emit launchSketch();
- }
- }
-}
-
-
-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 (aSelected.size() == 1) {
- ObjectPtr aObject = aSelected.first().object();
- if (aObject) {
- restartOperation(PartSet_OperationFeatureEdit::Type(), aObject);
- }
- }
- }
-}
-
-void PartSet_OperationSketch::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
-{
- if (!hasSketchPlane() || !(theEvent->buttons() & Qt::LeftButton) || myFeatures.empty())
- return;
-
- // myFeatures are not filled in the previous realization, so, this code is just commented
- // because has no effect
- /*if (myFeatures.size() != 1) {
- Handle(V3d_View) aView = theViewer->activeView();
- ObjectPtr aFeature = PartSet_Tools::nearestFeature(theEvent->pos(), aView, feature(),
- myFeatures);
- if (aFeature)
- restartOperation(PartSet_OperationFeatureEdit::Type(), aFeature);
- }*/
-}
-
-std::list<FeaturePtr> PartSet_OperationSketch::subFeatures() const
-{
- std::list<FeaturePtr> aFeaList;
- FeaturePtr aFeature = feature();
- if (!aFeature)
- return aFeaList;
-
- std::shared_ptr<ModelAPI_Data> aData = aFeature->data();
- if (!aData->isValid())
- return std::list<FeaturePtr>();
- std::shared_ptr<ModelAPI_AttributeRefList> aRefList = std::dynamic_pointer_cast<
- ModelAPI_AttributeRefList>(aData->attribute(SketchPlugin_Sketch::FEATURES_ID()));
-
- std::list<ObjectPtr> aList = aRefList->list();
- std::list<ObjectPtr>::iterator aIt;
- for (aIt = aList.begin(); aIt != aList.end(); ++aIt) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*aIt);
- if (aFeature)
- aFeaList.push_back(aFeature);
- }
- return aFeaList;
-}
-
-void PartSet_OperationSketch::stopOperation()
-{
- PartSet_OperationSketchBase::stopOperation();
- emit featureConstructed(feature(), FM_Hide);
-}
-
-void PartSet_OperationSketch::afterCommitOperation()
-{
- FeaturePtr aFeature = feature();
- std::list<ResultPtr> aResults = aFeature->results();
- std::list<ResultPtr>::const_iterator aIt;
- Events_ID anEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_TOSHOW);
- for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
- ModelAPI_EventCreator::get()->sendUpdated(*aIt, anEvent);
- }
- Events_Loop::loop()->flush(anEvent);
-}
-
-bool PartSet_OperationSketch::isNestedOperationsEnabled() const
-{
- return hasSketchPlane();
-}
-
-void PartSet_OperationSketch::startOperation()
-{
- PartSet_OperationSketchBase::startOperation();
- if (!isEditOperation())
- emit fitAllView();
-}
-
-bool PartSet_OperationSketch::hasSketchPlane() const
-{
- bool aHasPlane = false;
-
- if (feature()) {
- std::shared_ptr<ModelAPI_Data> aData = feature()->data();
- AttributeDoublePtr anAttr;
- std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- aData->attribute(SketchPlugin_Sketch::NORM_ID()));
- aHasPlane = aNormal && !(aNormal->x() == 0 && aNormal->y() == 0 && aNormal->z() == 0);
- }
- return aHasPlane;
-}
-
-std::shared_ptr<GeomAPI_Dir> PartSet_OperationSketch::setSketchPlane(const TopoDS_Shape& theShape)
-{
- if (theShape.IsNull())
- return std::shared_ptr<GeomAPI_Dir>();
-
- // get selected shape
- std::shared_ptr<GeomAPI_Shape> aGShape(new GeomAPI_Shape);
- aGShape->setImpl(new TopoDS_Shape(theShape));
-
- // get plane parameters
- std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
-
- // set plane parameters to feature
- std::shared_ptr<ModelAPI_Data> aData = feature()->data();
- double anA, aB, aC, aD;
- aPlane->coefficients(anA, aB, aC, aD);
-
- // calculate attributes of the sketch
- std::shared_ptr<GeomAPI_Dir> aNormDir(new GeomAPI_Dir(anA, aB, aC));
- std::shared_ptr<GeomAPI_XYZ> aCoords = aNormDir->xyz();
- std::shared_ptr<GeomAPI_XYZ> aZero(new GeomAPI_XYZ(0, 0, 0));
- aCoords = aCoords->multiplied(-aD * aCoords->distance(aZero));
- std::shared_ptr<GeomAPI_Pnt> anOrigPnt(new GeomAPI_Pnt(aCoords));
- // X axis is preferable to be dirX on the sketch
- const double tol = Precision::Confusion();
- bool isX = fabs(anA - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol;
- std::shared_ptr<GeomAPI_Dir> aTempDir(
- isX ? new GeomAPI_Dir(0, 1, 0) : new GeomAPI_Dir(1, 0, 0));
- std::shared_ptr<GeomAPI_Dir> aYDir(new GeomAPI_Dir(aNormDir->cross(aTempDir)));
- std::shared_ptr<GeomAPI_Dir> aXDir(new GeomAPI_Dir(aYDir->cross(aNormDir)));
-
- std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
- aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
- anOrigin->setValue(anOrigPnt);
- std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- aData->attribute(SketchPlugin_Sketch::NORM_ID()));
- aNormal->setValue(aNormDir);
- std::shared_ptr<GeomDataAPI_Dir> aDirX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
- aDirX->setValue(aXDir);
- std::shared_ptr<GeomDataAPI_Dir> aDirY = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- aData->attribute(SketchPlugin_Sketch::DIRY_ID()));
- aDirY->setValue(aYDir);
- std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
- return aDir;
-}
-
-
-bool PartSet_OperationSketch::isGranted(ModuleBase_Operation* theOperation) const
-{
- PartSet_OperationSketchBase* aPreviewOp = dynamic_cast<PartSet_OperationSketchBase*>(theOperation);
- return aPreviewOp != NULL;
-}
-
+++ /dev/null
-// File: PartSet_OperationSketch.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_OperationSketch_H
-#define PartSet_OperationSketch_H
-
-#include "PartSet.h"
-
-#include <PartSet_OperationSketchBase.h>
-
-#include <SketchPlugin_Sketch.h>
-
-#include <QObject>
-#include <QList>
-
-class Handle_AIS_InteractiveObject;
-
-/*!
- \class PartSet_OperationSketch
- * \brief The operation for the sketch feature creation
- */
-class PARTSET_EXPORT PartSet_OperationSketch : public PartSet_OperationSketchBase
-{
-Q_OBJECT
- public:
- /// Returns the operation type key
- static std::string Type()
- {
- return SketchPlugin_Sketch::ID();
- }
-
- public:
- /// Constructor
- /// \param theId the feature identifier
- /// \param theParent the operation parent
- PartSet_OperationSketch(const QString& theId, QObject* theParent);
- /// Destructor
- virtual ~PartSet_OperationSketch();
-
- /// Returns True if the given operation is a Sketcher operation
- virtual bool isGranted(ModuleBase_Operation* theOperation) const;
-
-
- /// Returns the operation sketch feature
- /// \returns the sketch instance
- virtual CompositeFeaturePtr sketch() const;
-
- /// Processes the mouse pressed 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 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, 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, ModuleBase_IViewer* theViewer);
-
- /// Returns the list of the nested features
- /// \return the list of subfeatures
- virtual std::list<FeaturePtr> subFeatures() const;
-
- /// Virtual method called when operation stopped - committed or aborted.
- /// Emits a signal to hide the preview of the operation
- virtual void stopOperation();
-
- /// Returns whether the nested operations are enabled.
- /// The state can depend on the operation current state.
- /// It returns true after the sketch plane is choosen.
- /// \return enabled state
- virtual bool isNestedOperationsEnabled() const;
-
- /// Returns whether the sketch plane is set
- /// \return the boolean value whether the sketch is set
- bool hasSketchPlane() const;
-
- /// Set the plane to the current sketch
- /// \param theShape the shape
- /// \return selected direction
- std::shared_ptr<GeomAPI_Dir> 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 bool hasPreview() const { return false; }
-
-signals:
- /// signal about the sketch plane is selected
- /// \param theX the value in the X direction of the plane
- /// \param theX the value in the Y direction value of the plane
- /// \param theX the value in the Z direction of the plane
- void planeSelected(double theX, double theY, double theZ);
- // signal about the viewer fit all perform
- void fitAllView();
-
- /// Signal to define sketch mode
- void launchSketch();
-
- /// Signal to update property panel
- void updatePropPanel();
-
- protected:
- /// Virtual method called when operation started (see start() method for more description)
- /// Default impl calls corresponding slot and commits immediately.
- virtual void startOperation();
-
- /// Virtual method called after operation committed (see commit() method for more description)
- virtual void afterCommitOperation();
-
- private:
- QList<ModuleBase_ViewerPrs> myFeatures; ///< the features to apply the edit operation
-};
-
-#endif
+++ /dev/null
-// File: PartSet_OperationSketchBase.cpp
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#include <PartSet_OperationSketchBase.h>
-#include <PartSet_Tools.h>
-#include <ModelAPI_ResultBody.h>
-
-#include <ModuleBase_IPropertyPanel.h>
-#include <ModuleBase_IViewer.h>
-#include <ModuleBase_ModelWidget.h>
-#include <ModuleBase_WidgetValueFeature.h>
-
-#include <SketchPlugin_Feature.h>
-#include <V3d_View.hxx>
-#include <AIS_Shape.hxx>
-#include <AIS_DimensionSelectionMode.hxx>
-
-#include <QKeyEvent>
-#include <QMessageBox>
-#include <QApplication>
-
-#ifdef _DEBUG
-#include <QDebug>
-#endif
-
-using namespace std;
-
-PartSet_OperationSketchBase::PartSet_OperationSketchBase(const QString& theId, QObject* theParent)
- : ModuleBase_Operation(theId, theParent)
-{
-}
-
-PartSet_OperationSketchBase::~PartSet_OperationSketchBase()
-{
-}
-
-std::shared_ptr<GeomAPI_Shape> PartSet_OperationSketchBase::preview(FeaturePtr theFeature)
-{
- std::shared_ptr<SketchPlugin_Feature> aFeature = std::dynamic_pointer_cast<
- SketchPlugin_Feature>(theFeature);
- if (aFeature) {
- ResultPtr aRes = aFeature->firstResult();
- ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aRes);
- if (aBody)
- return aBody->shape();
- }
- return std::shared_ptr<GeomAPI_Shape>();
-}
-
-std::list<FeaturePtr> PartSet_OperationSketchBase::subFeatures() const
-{
- return std::list<FeaturePtr>();
-}
-
-FeaturePtr PartSet_OperationSketchBase::createFeature(const bool theFlushMessage)
-{
- ModuleBase_Operation::createFeature(theFlushMessage);
- if (myFeature)
- emit featureConstructed(myFeature, FM_Activation);
- return myFeature;
-}
-
-void PartSet_OperationSketchBase::mousePressed(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer, ModuleBase_ISelection* theSelection)
-{
-}
-void PartSet_OperationSketchBase::mouseReleased(
- QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
- ModuleBase_ISelection* theSelection)
-{
-}
-void PartSet_OperationSketchBase::mouseMoved(QMouseEvent* theEvent, ModuleBase_IViewer* theViewer)
-{
-}
-void PartSet_OperationSketchBase::mouseDoubleClick(
- QMouseEvent* theEvent, Handle_V3d_View theView,
- ModuleBase_ISelection* theSelection)
-{
-}
-
-void PartSet_OperationSketchBase::selectionChanged(ModuleBase_ISelection* theSelection)
-{
-}
-
-void PartSet_OperationSketchBase::restartOperation(const std::string& theType, ObjectPtr theFeature)
-{
- FeaturePtr aFeature = ModelAPI_Feature::feature(theFeature);
- if (aFeature) {
- QStringList aNested = this->nestedFeatures();
- if (!aNested.isEmpty()) {
- if (!aNested.contains(QString(aFeature->getKind().c_str())))
- return;
- }
- }
- emit restartRequired(theType, theFeature);
-}
-
-
+++ /dev/null
-// File: PartSet_OperationSketchBase.h
-// Created: 20 Apr 2014
-// Author: Natalia ERMOLAEVA
-
-#ifndef PartSet_OperationSketchBase_H
-#define PartSet_OperationSketchBase_H
-
-#include "PartSet.h"
-
-#include <TopoDS_Shape.hxx>
-#include <gp_Pnt.hxx>
-#include <NCollection_List.hxx>
-
-#include <ModuleBase_Operation.h>
-#include <ModuleBase_Operation.h>
-
-#include <XGUI_Constants.h>
-#include <XGUI_Displayer.h>
-
-#include <QObject>
-
-#include <AIS_InteractiveObject.hxx>
-
-#include <map>
-
-class Handle_V3d_View;
-class QMouseEvent;
-class GeomAPI_Shape;
-class ModuleBase_ViewerPrs;
-class ModuleBase_ISelection;
-class ModuleBase_IViewer;
-
-/*!
- \class PartSet_OperationSketchBase
- * \brief The base operation for the sketch features.
- * Base class for all sketch operations. It provides an access to the feature preview
- */
-class PARTSET_EXPORT PartSet_OperationSketchBase : public ModuleBase_Operation
-{
-Q_OBJECT
- public:
- enum FeatureActionMode
- {
- FM_Activation,
- FM_Deactivation,
- FM_Hide
- };
-
- public:
- /// Constructor
- /// \param theId an feature index
- /// \param theParent the object parent
- PartSet_OperationSketchBase(const QString& theId, QObject* theParent);
- /// Destructor
- virtual ~PartSet_OperationSketchBase();
-
- /// Returns the feature preview shape
- /// \param theFeature the feature object to obtain the preview
- static std::shared_ptr<GeomAPI_Shape> preview(FeaturePtr theFeature);
-
- /// Returns the list of the nested features
- /// \return the list of subfeatures
- virtual std::list<FeaturePtr> subFeatures() const;
-
- /// Returns the operation sketch feature
- /// \returns the sketch instance
- virtual CompositeFeaturePtr sketch() const = 0;
-
- /// Processes the mouse pressed 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 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, 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, ModuleBase_IViewer* theViewer);
-
- /// Processes the mouse double click 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 mouseDoubleClick(QMouseEvent* theEvent, Handle_V3d_View theView,
- 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.
- /// \param theType a type of an operation started
- /// theFeature the operation argument
- void restartOperation(const std::string& theType, ObjectPtr theFeature = ObjectPtr());
-
- /// If operation needs to redisplay its result during operation
- /// then this method has to return True
- virtual bool hasPreview() const { return true; }
-
-signals:
- /// signal about the request to launch operation
- /// theName the operation name
- /// theFeature the operation argument
- void restartRequired(std::string theName, ObjectPtr theFeature);
-
- /// Signal about the feature construing is finished
- /// \param theFeature the result feature
- /// \param theMode the mode of the feature modification
- void featureConstructed(ObjectPtr theFeature, int theMode);
-
- /// Signal about the features should be selected
- /// \param theSelected the list of selected presentations
- void featureSelected(const std::list<ModuleBase_ViewerPrs>& theSelected);
-
- /// signal to enable/disable multi selection in the viewer
- /// \param theEnabled the boolean state
- //void multiSelectionEnabled(bool theEnabled);
-
- /// signal to enable/disable selection in the viewer
- /// \param theFeatures a list of features to be disabled
- /// \param theToStop the boolean state whether it it stopped or non stopped
- void stopSelection(const QList<ObjectPtr>& theFeatures, const bool theToStop);
-
- /// signal to set selection in the viewer
- /// \param theFeatures a list of features to be disabled
- void setSelection(const QList<ObjectPtr>& theFeatures);
-
- protected:
- /// Creates an operation new feature
- /// In addition to the default realization it appends the created line feature to
- /// the sketch feature
- /// \param theFlushMessage the flag whether the create message should be flushed
- /// \returns the created feature
- virtual FeaturePtr createFeature(const bool theFlushMessage = true);
-};
-
-#endif
std::shared_ptr<GeomAPI_Pln> PartSet_Tools::sketchPlane(CompositeFeaturePtr theSketch)
{
std::shared_ptr<GeomAPI_Pln> aPlane;
- double aA, aB, aC, aD;
std::shared_ptr<ModelAPI_Data> aData = theSketch->data();
std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
aData->attribute(SketchPlugin_Sketch::NORM_ID()));
- aA = aNormal->x();
- aB = aNormal->y();
- aC = aNormal->z();
- aD = 0;
-
- aPlane = std::shared_ptr<GeomAPI_Pln>(new GeomAPI_Pln(aA, aB, aC, aD));
+ if (aNormal && anOrigin) {
+ double adX = aNormal->x();
+ double adY = aNormal->y();
+ double adZ = aNormal->z();
+
+ if ( (adX != 0) || (adY != 0) || (adZ != 0) ) { // Plane is valid
+ double aX = anOrigin->x();
+ double aY = anOrigin->y();
+ double aZ = anOrigin->z();
+ gp_Pln aPln(gp_Pnt(aX, aY, aZ), gp_Dir(adX, adY, adZ));
+ double aA, aB, aC, aD;
+ aPln.Coefficients(aA, aB, aC, aD);
+ aPlane = std::shared_ptr<GeomAPI_Pln>(new GeomAPI_Pln(aA, aB, aC, aD));
+ }
+ }
return aPlane;
}
/// Converts the 2D screen point to the 3D point on the view according to the point of view
/// \param thePoint a screen point
/// \param theView a 3D view
+ // Transferred to ModuleBase
static gp_Pnt convertClickToPoint(QPoint thePoint, Handle_V3d_View theView);
/// \brief Converts the 3D point to the projected coodinates on the sketch plane.
/// \param theX the X coordinate
/// \param theY the Y coordinate
static void convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch,
- Handle(V3d_View) theView,
+ Handle(V3d_View) theView,
double& theX, double& theY);
/// \brief Converts the 2D projected coodinates on the sketch plane to the 3D point.
--- /dev/null
+// File: PartSet_WidgetPoint2D.cpp
+// Created: 25 Apr 2014
+// Author: Natalia ERMOLAEVA
+
+#include "PartSet_WidgetPoint2D.h"
+#include "PartSet_Tools.h"
+
+#include <XGUI_Workshop.h>
+#include <XGUI_ViewerProxy.h>
+#include <XGUI_ModuleConnector.h>
+#include <XGUI_SelectionMgr.h>
+#include <XGUI_Selection.h>
+
+#include <ModuleBase_WidgetValueFeature.h>
+#include <ModuleBase_DoubleSpinBox.h>
+#include <ModuleBase_Tools.h>
+#include <ModuleBase_IViewWindow.h>
+
+#include <Config_Keywords.h>
+#include <Config_WidgetAPI.h>
+
+#include <Events_Loop.h>
+#include <ModelAPI_Events.h>
+
+#include <ModelAPI_Feature.h>
+#include <ModelAPI_Data.h>
+#include <ModelAPI_Object.h>
+#include <GeomDataAPI_Point2D.h>
+#include <GeomAPI_Pnt2d.h>
+
+#include <QGroupBox>
+#include <QGridLayout>
+#include <QLabel>
+#include <QEvent>
+#include <QMouseEvent>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <BRep_Tool.hxx>
+
+#include <cfloat>
+#include <climits>
+
+PartSet_WidgetPoint2D::PartSet_WidgetPoint2D(QWidget* theParent,
+ const Config_WidgetAPI* theData,
+ const std::string& theParentId)
+ : ModuleBase_ModelWidget(theParent, theData, theParentId)
+{
+ //myOptionParam = theData->getProperty(PREVIOUS_FEATURE_PARAM);
+ QString aPageName = QString::fromStdString(theData->getProperty(CONTAINER_PAGE_NAME));
+ myGroupBox = new QGroupBox(aPageName, theParent);
+ myGroupBox->setFlat(false);
+
+ QGridLayout* aGroupLay = new QGridLayout(myGroupBox);
+ ModuleBase_Tools::adjustMargins(aGroupLay);
+ aGroupLay->setColumnStretch(1, 1);
+ {
+ QLabel* aLabel = new QLabel(myGroupBox);
+ aLabel->setText("X");
+ aLabel->setPixmap(QPixmap(":pictures/x_point.png"));
+ aGroupLay->addWidget(aLabel, 0, 0);
+
+ myXSpin = new ModuleBase_DoubleSpinBox(myGroupBox);
+ myXSpin->setMinimum(-DBL_MAX);
+ myXSpin->setMaximum(DBL_MAX);
+ myXSpin->setToolTip("X");
+ aGroupLay->addWidget(myXSpin, 0, 1);
+
+ connect(myXSpin, SIGNAL(valueChanged(double)), this, SIGNAL(valuesChanged()));
+ }
+ {
+ QLabel* aLabel = new QLabel(myGroupBox);
+ aLabel->setText("Y");
+ aLabel->setPixmap(QPixmap(":pictures/y_point.png"));
+ aGroupLay->addWidget(aLabel, 1, 0);
+
+ myYSpin = new ModuleBase_DoubleSpinBox(myGroupBox);
+ myYSpin->setMinimum(-DBL_MAX);
+ myYSpin->setMaximum(DBL_MAX);
+ myYSpin->setToolTip("X");
+ aGroupLay->addWidget(myYSpin, 1, 1);
+
+ connect(myYSpin, SIGNAL(valueChanged(double)), this, SIGNAL(valuesChanged()));
+ }
+}
+
+PartSet_WidgetPoint2D::~PartSet_WidgetPoint2D()
+{
+}
+
+bool PartSet_WidgetPoint2D::setValue(ModuleBase_WidgetValue* theValue)
+{
+ bool isDone = false;
+ if (theValue) {
+ ModuleBase_WidgetValueFeature* aFeatureValue =
+ dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
+ if (aFeatureValue) {
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint = aFeatureValue->point();
+ if (aPoint) {
+ setPoint(aPoint->x(), aPoint->y());
+ isDone = true;
+ }
+ }
+ }
+ return isDone;
+}
+
+void PartSet_WidgetPoint2D::setPoint(double theX, double theY)
+{
+
+ bool isBlocked = this->blockSignals(true);
+ myXSpin->setValue(theX);
+ myYSpin->setValue(theY);
+ this->blockSignals(isBlocked);
+
+ emit valuesChanged();
+}
+
+bool PartSet_WidgetPoint2D::storeValue() const
+{
+ std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
+ std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ aData->attribute(attributeID()));
+
+ PartSet_WidgetPoint2D* that = (PartSet_WidgetPoint2D*) this;
+ bool isBlocked = that->blockSignals(true);
+ bool isImmutable = aPoint->setImmutable(true);
+#ifdef _DEBUG
+ std::string _attr_name = myAttributeID;
+ double _X = myXSpin->value();
+ double _Y = myYSpin->value();
+#endif
+ aPoint->setValue(myXSpin->value(), myYSpin->value());
+ updateObject(myFeature);
+ aPoint->setImmutable(isImmutable);
+ that->blockSignals(isBlocked);
+
+ return true;
+}
+
+bool PartSet_WidgetPoint2D::restoreValue()
+{
+ std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
+ std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ aData->attribute(attributeID()));
+
+#ifdef _DEBUG
+ std::string _attr_name = myAttributeID;
+ double _X = aPoint->x();
+ double _Y = aPoint->y();
+#endif
+ bool isBlocked = this->blockSignals(true);
+ myXSpin->setValue(aPoint->x());
+ myYSpin->setValue(aPoint->y());
+ this->blockSignals(isBlocked);
+ return true;
+}
+
+QWidget* PartSet_WidgetPoint2D::getControl() const
+{
+ return myGroupBox;
+}
+
+QList<QWidget*> PartSet_WidgetPoint2D::getControls() const
+{
+ QList<QWidget*> aControls;
+ aControls.append(myXSpin);
+ aControls.append(myYSpin);
+ return aControls;
+}
+
+//bool PartSet_WidgetPoint2D::initFromPrevious(ObjectPtr theObject)
+//{
+// if (myOptionParam.length() == 0)
+// return false;
+// std::shared_ptr<ModelAPI_Data> aData = theObject->data();
+// std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+// aData->attribute(myOptionParam));
+// if (aPoint) {
+// bool isBlocked = this->blockSignals(true);
+// myXSpin->setValue(aPoint->x());
+// myYSpin->setValue(aPoint->y());
+// this->blockSignals(isBlocked);
+//
+// emit valuesChanged();
+// emit storedPoint2D(theObject, myOptionParam);
+// return true;
+// }
+// return false;
+//}
+
+void PartSet_WidgetPoint2D::activate()
+{
+ XGUI_ViewerProxy* aViewer = myWorkshop->viewer();
+ connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMove(ModuleBase_IViewWindow*, QMouseEvent*)));
+ connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)));
+
+ QIntList aModes;
+ aModes << TopAbs_VERTEX;
+ myWorkshop->moduleConnector()->activateSubShapesSelection(aModes);
+}
+
+void PartSet_WidgetPoint2D::deactivate()
+{
+ ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+ disconnect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMove(ModuleBase_IViewWindow*, QMouseEvent*)));
+ disconnect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)));
+ myWorkshop->moduleConnector()->deactivateSubShapesSelection();
+}
+
+
+void PartSet_WidgetPoint2D::onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
+{
+ XGUI_Selection* aSelection = myWorkshop->selector()->selection();
+ NCollection_List<TopoDS_Shape> aShapes;
+ std::list<ObjectPtr> aObjects;
+ aSelection->selectedShapes(aShapes, aObjects);
+ if (aShapes.Extent() > 0) {
+ TopoDS_Shape aShape = aShapes.First();
+ if (!aShape.IsNull()) {
+ if (aShape.ShapeType() == TopAbs_VERTEX) {
+ const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape);
+ if (!aVertex.IsNull()) {
+ // A case when point is taken from existing vertex
+ gp_Pnt aPoint = BRep_Tool::Pnt(aVertex);
+ double aX, aY;
+ PartSet_Tools::convertTo2D(aPoint, mySketch, theWnd->v3dView(), aX, aY);
+ setPoint(aX, aY);
+ emit vertexSelected(aObjects.front(), aShape);
+ emit focusOutWidget(this);
+ return;
+ }
+ }
+ }
+ }
+ // A case when point is taken from mouse event
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWnd->v3dView());
+ double aX, anY;
+ PartSet_Tools::convertTo2D(aPoint, mySketch, theWnd->v3dView(), aX, anY);
+ setPoint(aX, anY);
+
+ emit focusOutWidget(this);
+}
+
+
+void PartSet_WidgetPoint2D::onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
+{
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWnd->v3dView());
+
+ double aX, anY;
+ PartSet_Tools::convertTo2D(aPoint, mySketch, theWnd->v3dView(), aX, anY);
+ setPoint(aX, anY);
+}
+
+double PartSet_WidgetPoint2D::x() const
+{
+ return myXSpin->value();
+}
+
+double PartSet_WidgetPoint2D::y() const
+{
+ return myYSpin->value();
+}
+
--- /dev/null
+// File: PartSet_WidgetPoint2D.h
+// Created: 25 Apr 2014
+// Author: Natalia ERMOLAEVA
+
+#ifndef PartSet_WidgetPoint2D_H
+#define PartSet_WidgetPoint2D_H
+
+#include "PartSet.h"
+#include <ModelAPI_CompositeFeature.h>
+#include <ModuleBase_ModelWidget.h>
+
+#include <QObject>
+
+#include <TopoDS_Shape.hxx>
+
+class ModelAPI_Feature;
+class ModuleBase_WidgetValue;
+class ModuleBase_IWorkshop;
+class ModuleBase_DoubleSpinBox;
+class ModuleBase_IViewWindow;
+class GeomAPI_Pnt2d;
+class XGUI_Workshop;
+
+class QGroupBox;
+class QMouseEvent;
+
+/**\class PartSet_WidgetPoint2D
+ * \ingroup GUI
+ * \brief Custom widget. An abstract class to be redefined to fill with some GUI controls
+ */
+class PARTSET_EXPORT PartSet_WidgetPoint2D : public ModuleBase_ModelWidget
+{
+Q_OBJECT
+ public:
+ /// Constructor
+ /// \theParent the parent object
+ /// \theParent the parent object
+ /// \theData the widget configuation. The attribute of the model widget is obtained from
+ PartSet_WidgetPoint2D(QWidget* theParent, const Config_WidgetAPI* theData,
+ const std::string& theParentId);
+ /// Destructor
+ virtual ~PartSet_WidgetPoint2D();
+
+ /// Set the given wrapped value to the current widget
+ /// This value should be processed in the widget according to the needs
+ /// \param theValue the wrapped widget value
+ virtual bool setValue(ModuleBase_WidgetValue* theValue);
+
+ /// Saves the internal parameters to the given feature
+ /// \param theObject a model feature to be changed
+ virtual bool storeValue() const;
+
+ virtual bool restoreValue();
+
+ /// Returns the internal parent wiget control, that can be shown anywhere
+ /// \returns the widget
+ QWidget* getControl() const;
+
+ /// Returns list of widget controls
+ /// \return a control list
+ virtual QList<QWidget*> getControls() const;
+
+ //bool initFromPrevious(ObjectPtr theObject);
+
+ /// The methiod called when widget is activated
+ virtual void activate();
+
+ /// The methiod called when widget is deactivated
+ virtual void deactivate();
+
+ XGUI_Workshop* workshop() const { return myWorkshop; }
+
+ void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
+
+ /// \returns the sketch instance
+ CompositeFeaturePtr sketch() const { return mySketch; }
+ void setSketch(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
+
+ /// Fill the widget values by given point
+ /// \param thePoint the point
+ void setPoint(double theX, double theY);
+
+ /// Returns coordinate X currently defined in the control
+ double x() const;
+
+ /// Returns coordinate Y currently defined in the control
+ double y() const;
+
+signals:
+ /// Signal about selection of an existing vertex from an object
+ /// \param theObject - the selected object
+ /// \param theShape - the selected shape
+ void vertexSelected(ObjectPtr theObject, const TopoDS_Shape& theShape);
+
+protected slots:
+ void onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+ void onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+
+ private:
+ XGUI_Workshop* myWorkshop;
+
+ QGroupBox* myGroupBox; ///< the parent group box for all intenal widgets
+ ModuleBase_DoubleSpinBox* myXSpin; ///< the spin box for the X coordinate
+ ModuleBase_DoubleSpinBox* myYSpin; ///< the spin box for the Y coordinate
+
+ //std::string myOptionParam; /// Parameter name which has to be taken from previous feature
+
+ CompositeFeaturePtr mySketch;
+};
+
+#endif
--- /dev/null
+// File: PartSet_WidgetPoint2dDistance.h
+// Created: 23 June 2014
+// Author: Vitaly Smetannikov
+
+#include "PartSet_WidgetPoint2dDistance.h"
+#include "PartSet_Tools.h"
+
+#include <ModuleBase_WidgetValueFeature.h>
+#include <ModuleBase_DoubleSpinBox.h>
+#include <ModuleBase_IViewWindow.h>
+
+#include <XGUI_ViewerProxy.h>
+#include <XGUI_Workshop.h>
+
+#include <GeomAPI_Pnt2d.h>
+#include <Config_WidgetAPI.h>
+#include <GeomDataAPI_Point2D.h>
+
+#include <ModelAPI_Data.h>
+#include <ModelAPI_AttributeDouble.h>
+
+#include <QMouseEvent>
+
+PartSet_WidgetPoint2dDistance::PartSet_WidgetPoint2dDistance(QWidget* theParent,
+ const Config_WidgetAPI* theData,
+ const std::string& theParentId)
+ : ModuleBase_WidgetDoubleValue(theParent, theData, theParentId)
+{
+ myFirstPntName = theData->getProperty("first_point");
+}
+
+PartSet_WidgetPoint2dDistance::~PartSet_WidgetPoint2dDistance()
+{
+}
+
+//bool PartSet_WidgetPoint2dDistance::setValue(ModuleBase_WidgetValue* theValue)
+//{
+// bool isDone = false;
+//
+// if (theValue) {
+// ModuleBase_WidgetValueFeature* aFeatureValue =
+// dynamic_cast<ModuleBase_WidgetValueFeature*>(theValue);
+// if (aFeatureValue) {
+// std::shared_ptr<GeomAPI_Pnt2d> aPnt = aFeatureValue->point();
+// ObjectPtr aObject = aFeatureValue->object();
+// FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
+// if (aFeature && aPnt) {
+// setPoint(aFeature, aPnt);
+// isDone = true;
+// }
+// }
+// }
+// return isDone;
+//}
+
+void PartSet_WidgetPoint2dDistance::setPoint(FeaturePtr theFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePnt)
+{
+ std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
+ std::shared_ptr<GeomDataAPI_Point2D> aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ aData->attribute(myFirstPntName));
+ if (!aPoint)
+ return;
+
+ double aRadius = thePnt->distance(aPoint->pnt());
+ AttributeDoublePtr aReal = aData->real(attributeID());
+ if (aReal && (aReal->value() != aRadius)) {
+ aReal->setValue(aRadius);
+ mySpinBox->setValue(aRadius);
+ }
+}
+
+void PartSet_WidgetPoint2dDistance::activate()
+{
+ XGUI_ViewerProxy* aViewer = myWorkshop->viewer();
+ connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMove(ModuleBase_IViewWindow*, QMouseEvent*)));
+ connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)));
+}
+
+void PartSet_WidgetPoint2dDistance::deactivate()
+{
+ ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+ disconnect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseMove(ModuleBase_IViewWindow*, QMouseEvent*)));
+ disconnect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
+ this, SLOT(onMouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)));
+}
+
+void PartSet_WidgetPoint2dDistance::onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
+{
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWnd->v3dView());
+
+ double aX, aY;
+ PartSet_Tools::convertTo2D(aPoint, mySketch, theWnd->v3dView(), aX, aY);
+
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt = std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aX, aY));
+ setPoint(feature(), aPnt);
+ emit focusOutWidget(this);
+}
+
+void PartSet_WidgetPoint2dDistance::onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
+{
+ gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theWnd->v3dView());
+
+ double aX, aY;
+ PartSet_Tools::convertTo2D(aPoint, mySketch, theWnd->v3dView(), aX, aY);
+
+ std::shared_ptr<GeomAPI_Pnt2d> aPnt = std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aX, aY));
+ setPoint(feature(), aPnt);
+}
+
+
--- /dev/null
+// File: PartSet_WidgetPoint2dDistance.h
+// Created: 23 June 2014
+// Author: Vitaly Smetannikov
+
+#ifndef PartSet_WidgetPoint2dDistance_H
+#define PartSet_WidgetPoint2dDistance_H
+
+#include "PartSet.h"
+#include <ModuleBase_WidgetDoubleValue.h>
+
+#include <ModelAPI_CompositeFeature.h>
+
+//class ModuleBase_WidgetValue;
+class GeomAPI_Pnt2d;
+class XGUI_Workshop;
+class ModuleBase_IViewWindow;
+class QMouseEvent;
+
+class PARTSET_EXPORT PartSet_WidgetPoint2dDistance : public ModuleBase_WidgetDoubleValue
+{
+Q_OBJECT
+ public:
+ /// Constructor
+ /// \theParent the parent object
+ /// \theData the widget configuation. The attribute of the model widget is obtained from
+ PartSet_WidgetPoint2dDistance(QWidget* theParent, const Config_WidgetAPI* theData,
+ const std::string& theParentId);
+
+ virtual ~PartSet_WidgetPoint2dDistance();
+
+ /// The methiod called when widget is activated
+ virtual void activate();
+
+ /// The methiod called when widget is deactivated
+ virtual void deactivate();
+
+ /// Set the given wrapped value to the current widget
+ /// This value should be processed in the widget according to the needs
+ /// \param theValue the wrapped widget value
+ //virtual bool setValue(ModuleBase_WidgetValue* theValue);
+
+ XGUI_Workshop* workshop() const { return myWorkshop; }
+
+ void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
+
+ /// \returns the sketch instance
+ CompositeFeaturePtr sketch() const { return mySketch; }
+ void setSketch(CompositeFeaturePtr theSketch) { mySketch = theSketch; }
+
+ protected slots:
+ void onMouseRelease(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+ void onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
+
+protected:
+ /// Set the second point which defines a value in the widget as a distance with a first point defined by feature
+ void setPoint(FeaturePtr theFeature, const std::shared_ptr<GeomAPI_Pnt2d>& thePnt);
+
+ private:
+ XGUI_Workshop* myWorkshop;
+ std::string myFirstPntName;
+
+ CompositeFeaturePtr mySketch;
+};
+
+#endif
// Author: Vitaly SMETANNIKOV
#include "PartSet_WidgetSketchLabel.h"
-#include "PartSet_OperationSketch.h"
+#include "PartSet_Tools.h"
+
+#include <XGUI_Workshop.h>
+#include <XGUI_Displayer.h>
+#include <XGUI_SelectionMgr.h>
+#include <XGUI_Selection.h>
+#include <XGUI_ViewerProxy.h>
#include <ModuleBase_Operation.h>
-#include <XGUI_OperationMgr.h>
+#include <ModuleBase_ViewerPrs.h>
+
+#include <GeomAlgoAPI_FaceBuilder.h>
+#include <GeomDataAPI_Point.h>
+#include <GeomDataAPI_Dir.h>
+#include <GeomAPI_XYZ.h>
+
+#include <SketchPlugin_Sketch.h>
+
+#include <Precision.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <AIS_Shape.hxx>
+#include <AIS_DimensionSelectionMode.hxx>
#include <Config_WidgetAPI.h>
+#include <Config_PropManager.h>
#include <QLabel>
+#define PLANE_SIZE "200"
+#define SKETCH_WIDTH "4"
+
+
PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent,
const Config_WidgetAPI* theData,
const std::string& theParentId)
- : ModuleBase_ModelWidget(theParent, theData, theParentId)
+ : ModuleBase_ModelWidget(theParent, theData, theParentId), myPreviewDisplayed(false)
{
myText = QString::fromStdString(theData->getProperty("title"));
myLabel = new QLabel("", theParent);
myLabel->setIndent(5);
}
+PartSet_WidgetSketchLabel::~PartSet_WidgetSketchLabel()
+{
+ erasePreviewPlanes();
+}
+
QList<QWidget*> PartSet_WidgetSketchLabel::getControls() const
{
return QList<QWidget*>();
return myLabel;
}
-void PartSet_WidgetSketchLabel::setOperationsMgr(XGUI_OperationMgr* theMgr)
+void PartSet_WidgetSketchLabel::onPlaneSelected()
{
- ModuleBase_Operation* aOperation = theMgr->currentOperation();
- if (aOperation->inherits("PartSet_OperationSketch")) {
- PartSet_OperationSketch* aSketchOpe = static_cast<PartSet_OperationSketch*>(aOperation);
- updateLabel(aSketchOpe);
- connect(aSketchOpe, SIGNAL(updatePropPanel()), this,
- SLOT(onPlaneSelected()));
+ XGUI_Selection* aSelection = myWorkshop->selector()->selection();
+ QList<ModuleBase_ViewerPrs> aSelected = aSelection->getSelected();
+ if (!aSelected.empty()) {
+ ModuleBase_ViewerPrs aPrs = aSelected.first();
+ TopoDS_Shape aShape = aPrs.shape();
+ if (!aShape.IsNull()) {
+ std::shared_ptr<GeomAPI_Dir> aDir = setSketchPlane(aShape);
+ if (aDir) {
+ erasePreviewPlanes();
+
+ if (aPrs.object() && (feature() != aPrs.object())) {
+ DataPtr aData = feature()->data();
+ AttributeSelectionPtr aSelAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
+ (aData->attribute(SketchPlugin_Feature::EXTERNAL_ID()));
+ if (aSelAttr) {
+ ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aPrs.object());
+ if (aRes) {
+ GeomShapePtr aShapePtr(new GeomAPI_Shape());
+ aShapePtr->setImpl(new TopoDS_Shape(aShape));
+ aSelAttr->setValue(aRes, aShapePtr);
+ }
+ }
+ } else
+ myWorkshop->viewer()->setViewProjection(aDir->x(), aDir->y(), aDir->z());
+
+ // Clear text in the label
+ myLabel->setText("");
+ myLabel->setToolTip("");
+ disconnect(myWorkshop->selector(), SIGNAL(selectionChanged()),
+ this, SLOT(onPlaneSelected()));
+
+ // Clear selection mode and define sketching mode
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->removeSelectionFilter(myPlaneFilter);
+ aDisp->closeLocalContexts();
+ setSketchingMode();
+ }
+ }
}
}
-void PartSet_WidgetSketchLabel::onPlaneSelected()
+std::shared_ptr<GeomAPI_Pln> PartSet_WidgetSketchLabel::plane() const
{
- PartSet_OperationSketch* aSketchOpe = static_cast<PartSet_OperationSketch*>(sender());
- updateLabel(aSketchOpe);
+ CompositeFeaturePtr aSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myFeature);
+ return PartSet_Tools::sketchPlane(aSketch);
+
}
-void PartSet_WidgetSketchLabel::updateLabel(PartSet_OperationSketch* theSketchOpe)
+void PartSet_WidgetSketchLabel::activate()
{
- if (theSketchOpe->hasSketchPlane()) {
- myLabel->setText("");
- myLabel->setToolTip("");
+ std::shared_ptr<GeomAPI_Pln> aPlane = plane();
+ if (aPlane) {
+ setSketchingMode();
} else {
+ // We have to select a plane before any operation
+ showPreviewPlanes();
+
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->openLocalContext();
+ aDisp->activateObjectsOutOfContext(QIntList());
+ if (myPlaneFilter.IsNull())
+ myPlaneFilter = new StdSelect_FaceFilter(StdSelect_Plane);
+ aDisp->addSelectionFilter(myPlaneFilter);
+ QIntList aModes;
+ aModes << TopAbs_FACE;
+ aDisp->setSelectionModes(aModes);
+
myLabel->setText(myText);
myLabel->setToolTip(myTooltip);
+
+ connect(myWorkshop->selector(), SIGNAL(selectionChanged()), this, SLOT(onPlaneSelected()));
+ aDisp->updateViewer();
}
}
+
+void PartSet_WidgetSketchLabel::deactivate()
+{
+
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->removeSelectionFilter(myPlaneFilter);
+ //aDisp->removeSelectionFilter(mySketchFilter);
+ aDisp->closeLocalContexts();
+ erasePreviewPlanes();
+}
+
+void PartSet_WidgetSketchLabel::erasePreviewPlanes()
+{
+ if (myPreviewDisplayed) {
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->eraseAIS(myYZPlane, false);
+ aDisp->eraseAIS(myXZPlane, false);
+ aDisp->eraseAIS(myXYPlane, false);
+ myPreviewDisplayed = false;
+ }
+}
+
+void PartSet_WidgetSketchLabel::showPreviewPlanes()
+{
+ if (myPreviewDisplayed)
+ return;
+
+ if (!myYZPlane) { // If planes are not created
+ // Create Preview
+ std::shared_ptr<GeomAPI_Pnt> anOrigin(new GeomAPI_Pnt(0, 0, 0));
+ std::shared_ptr<GeomAPI_Dir> aYZDir(new GeomAPI_Dir(1, 0, 0));
+ std::shared_ptr<GeomAPI_Dir> aXZDir(new GeomAPI_Dir(0, 1, 0));
+ std::shared_ptr<GeomAPI_Dir> aXYDir(new GeomAPI_Dir(0, 0, 1));
+
+ int aR[] = {255, 0, 0};
+ int aG[] = {0, 255, 0};
+ int aB[] = {0, 0, 255};
+
+ myYZPlane = createPreviewPlane(anOrigin, aYZDir, aR);
+ myXZPlane = createPreviewPlane(anOrigin, aXZDir, aG);
+ myXYPlane = createPreviewPlane(anOrigin, aXYDir, aB);
+ }
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ aDisp->displayAIS(myYZPlane, false);
+ aDisp->displayAIS(myXZPlane, false);
+ aDisp->displayAIS(myXYPlane, false);
+ myPreviewDisplayed = true;
+}
+
+
+AISObjectPtr PartSet_WidgetSketchLabel::createPreviewPlane(std::shared_ptr<GeomAPI_Pnt> theOrigin,
+ std::shared_ptr<GeomAPI_Dir> theNorm,
+ const int theRGB[3])
+{
+ double aSize = Config_PropManager::integer("Sketch planes", "Size of planes", PLANE_SIZE);
+ std::shared_ptr<GeomAPI_Shape> aFace = GeomAlgoAPI_FaceBuilder::square(theOrigin, theNorm, aSize);
+ AISObjectPtr aAIS = AISObjectPtr(new GeomAPI_AISObject());
+ aAIS->createShape(aFace);
+ aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness", SKETCH_WIDTH));
+ aAIS->setColor(theRGB[0], theRGB[1], theRGB[2]);
+ return aAIS;
+}
+
+
+std::shared_ptr<GeomAPI_Dir> PartSet_WidgetSketchLabel::setSketchPlane(const TopoDS_Shape& theShape)
+{
+ if (theShape.IsNull())
+ return std::shared_ptr<GeomAPI_Dir>();
+
+ // get selected shape
+ std::shared_ptr<GeomAPI_Shape> aGShape(new GeomAPI_Shape);
+ aGShape->setImpl(new TopoDS_Shape(theShape));
+
+ // get plane parameters
+ std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
+
+ // set plane parameters to feature
+ std::shared_ptr<ModelAPI_Data> aData = feature()->data();
+ double anA, aB, aC, aD;
+ aPlane->coefficients(anA, aB, aC, aD);
+
+ // calculate attributes of the sketch
+ std::shared_ptr<GeomAPI_Dir> aNormDir(new GeomAPI_Dir(anA, aB, aC));
+ std::shared_ptr<GeomAPI_XYZ> aCoords = aNormDir->xyz();
+ std::shared_ptr<GeomAPI_XYZ> aZero(new GeomAPI_XYZ(0, 0, 0));
+ aCoords = aCoords->multiplied(-aD * aCoords->distance(aZero));
+ std::shared_ptr<GeomAPI_Pnt> anOrigPnt(new GeomAPI_Pnt(aCoords));
+ // X axis is preferable to be dirX on the sketch
+ const double tol = Precision::Confusion();
+ bool isX = fabs(anA - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol;
+ std::shared_ptr<GeomAPI_Dir> aTempDir(
+ isX ? new GeomAPI_Dir(0, 1, 0) : new GeomAPI_Dir(1, 0, 0));
+ std::shared_ptr<GeomAPI_Dir> aYDir(new GeomAPI_Dir(aNormDir->cross(aTempDir)));
+ std::shared_ptr<GeomAPI_Dir> aXDir(new GeomAPI_Dir(aYDir->cross(aNormDir)));
+
+ std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
+ aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
+ anOrigin->setValue(anOrigPnt);
+ std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::NORM_ID()));
+ aNormal->setValue(aNormDir);
+ std::shared_ptr<GeomDataAPI_Dir> aDirX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
+ aDirX->setValue(aXDir);
+ std::shared_ptr<GeomDataAPI_Dir> aDirY = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+ aData->attribute(SketchPlugin_Sketch::DIRY_ID()));
+ aDirY->setValue(aYDir);
+ std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
+ return aDir;
+}
+
+
+void PartSet_WidgetSketchLabel::setSketchingMode()
+{
+ XGUI_Displayer* aDisp = myWorkshop->displayer();
+ QIntList aModes;
+ // Clear standard selection modes if they are defined
+ aDisp->setSelectionModes(aModes);
+ aDisp->openLocalContext();
+
+ // Set filter
+ std::shared_ptr<GeomAPI_Pln> aPlane = plane();
+ double aA, aB, aC, aD;
+ aPlane->coefficients(aA, aB, aC, aD);
+ gp_Pln aPln(aA, aB, aC, aD);
+ // No selection of external objects
+ //mySketchFilter = new ModuleBase_ShapeInPlaneFilter(aPln);
+ //aDisp->addSelectionFilter(mySketchFilter);
+
+ // Get default selection modes
+ aModes.append(AIS_DSM_Text);
+ aModes.append(AIS_DSM_Line);
+ aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_VERTEX));
+ aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum) TopAbs_EDGE));
+
+ aDisp->activateObjectsOutOfContext(aModes);
+}
#include "PartSet.h"
#include <ModuleBase_ModelWidget.h>
+#include <ModuleBase_ViewerFilters.h>
+
+#include <GeomAPI_Pnt.h>
+#include <GeomAPI_Dir.h>
+#include <GeomAPI_AISObject.h>
+
+#include <StdSelect_FaceFilter.hxx>
+#include <TopoDS_Shape.hxx>
class QLabel;
class XGUI_OperationMgr;
-class PartSet_OperationSketch;
+class XGUI_Workshop;
+//class PartSet_OperationSketch;
class PARTSET_EXPORT PartSet_WidgetSketchLabel : public ModuleBase_ModelWidget
{
PartSet_WidgetSketchLabel(QWidget* theParent, const Config_WidgetAPI* theData,
const std::string& theParentId);
- virtual ~PartSet_WidgetSketchLabel()
- {
- }
+ virtual ~PartSet_WidgetSketchLabel();
/// Saves the internal parameters to the given feature
/// \param theFeature a model feature to be changed
QWidget* getControl() const;
- void setOperationsMgr(XGUI_OperationMgr* theMgr);
+ /// The methiod called when widget is activated
+ virtual void activate();
+
+ /// The methiod called when widget is deactivated
+ virtual void deactivate();
+
+ XGUI_Workshop* workshop() const { return myWorkshop; }
+
+ void setWorkshop(XGUI_Workshop* theWork) { myWorkshop = theWork; }
+
+ std::shared_ptr<GeomAPI_Pln> plane() const;
private slots:
void onPlaneSelected();
private:
- void updateLabel(PartSet_OperationSketch* theSketchOpe);
+ AISObjectPtr createPreviewPlane(std::shared_ptr<GeomAPI_Pnt> theOrigin,
+ std::shared_ptr<GeomAPI_Dir> theNorm,
+ const int theRGB[3]);
+
+ std::shared_ptr<GeomAPI_Dir> setSketchPlane(const TopoDS_Shape& theShape);
+
+ void erasePreviewPlanes();
+ void showPreviewPlanes();
+
+ void setSketchingMode();
QLabel* myLabel;
QString myText;
QString myTooltip;
+
+ XGUI_Workshop* myWorkshop;
+
+ AISObjectPtr myYZPlane;
+ AISObjectPtr myXZPlane;
+ AISObjectPtr myXYPlane;
+ bool myPreviewDisplayed;
+
+ Handle(StdSelect_FaceFilter) myPlaneFilter;
+ //Handle(ModuleBase_ShapeInPlaneFilter) mySketchFilter;
};
#endif
// value calculation
std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
ModelAPI_AttributeDouble>(aData->attribute(SketchPlugin_Constraint::VALUE()));
- double aValue = aValueAttr->value();
+ // TODO: has to be calculated on definition of reference object
+ double aValue;
// Issue #196: checking the positivity of the distance constraint
// there is a validator for a distance constraint, that the value should be positive
// in case if an invalid value is set, the current distance value is shown
- if (aValue <= 0)
+ if (aValueAttr->isInitialized())
+ aValue = aValueAttr->value();
+ else {
aValue = calculateCurrentDistance();
+ aValueAttr->setValue(aValue);
+ }
+ // End TODO
AISObjectPtr anAIS = thePrevious;
if (!anAIS)
double aLenght = aPoint1->pnt()->distance(aPoint2->pnt());
- std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
- ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
- if(!aValueAttr->isInitialized()) {
- aValueAttr->setValue(aLenght);
- }
+ //std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
+ // ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
+ //if(!aValueAttr->isInitialized()) {
+ // aValueAttr->setValue(aLenght);
+ //}
}
}
aFlyoutPnt = sketch()->to3D(aFPnt->x(), aFPnt->y());
}
// value calculation
+ // TODO: has to be calculated on definition of reference object
+ double aDistance = aPoint1->distance(aPoint2);
std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
- double aValue = aValueAttr->value();
+ double aValue = aDistance;
+ if (aValueAttr->isInitialized())
+ aValue = aValueAttr->value();
+ else
+ aValueAttr->setValue(aValue);
+ // End TODO
AISObjectPtr anAIS = thePrevious;
if (!anAIS)
if (aCenterAttr && aStartAttr)
aRadius = aCenterAttr->pnt()->distance(aStartAttr->pnt());
}
- std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
- ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
- if(!aValueAttr->isInitialized()) {
- aValueAttr->setValue(aRadius);
- }
+ //std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
+ // ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
+ //if(!aValueAttr->isInitialized()) {
+ // aValueAttr->setValue(aRadius);
+ //}
}
}
}
// Prepare a circle
- aData = aFeature->data();
+ std::shared_ptr<ModelAPI_Data> aCyrcData = aFeature->data();
std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr;
double aRadius;
if (aKind == SketchPlugin_Circle::ID()) {
aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(SketchPlugin_Circle::CENTER_ID()));
+ aCyrcData->attribute(SketchPlugin_Circle::CENTER_ID()));
AttributeDoublePtr aCircRadius = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
- aData->attribute(SketchPlugin_Circle::RADIUS_ID()));
+ aCyrcData->attribute(SketchPlugin_Circle::RADIUS_ID()));
aRadius = aCircRadius->value();
if (!aFlyoutPnt) {
double aShift = aRadius * 1.1;
}
} else if (aKind == SketchPlugin_Arc::ID()) {
aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- aData->attribute(SketchPlugin_Arc::CENTER_ID()));
+ aCyrcData->attribute(SketchPlugin_Arc::CENTER_ID()));
std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
- GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Arc::START_ID()));
+ GeomDataAPI_Point2D>(aCyrcData->attribute(SketchPlugin_Arc::START_ID()));
aRadius = aCenterAttr->pnt()->distance(aStartAttr->pnt());
if (!aFlyoutPnt) {
std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
- GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Arc::START_ID()));
+ GeomDataAPI_Point2D>(aCyrcData->attribute(SketchPlugin_Arc::START_ID()));
aFlyoutAttr->setValue(aStartAttr->pnt());
aFlyoutPnt = sketch()->to3D(aStartAttr->pnt()->x(), aStartAttr->pnt()->y());
}
std::shared_ptr<GeomAPI_Circ> aCircle(new GeomAPI_Circ(aCenter, aNormal, aRadius));
// Value
+ // TODO: has to be calculated on definition of reference object
std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
ModelAPI_AttributeDouble>(aData->attribute(SketchPlugin_Constraint::VALUE()));
double aValue = aRadius;
- if (aValueAttr && aValueAttr->isInitialized())
+ if (aValueAttr->isInitialized())
aValue = aValueAttr->value();
-
+ else {
+ aValueAttr->setValue(aValue);
+ }
+ // End TODO
AISObjectPtr anAIS = thePrevious;
if (!anAIS)
anAIS = AISObjectPtr(new GeomAPI_AISObject);
return std::shared_ptr<GeomAPI_Pln>(new GeomAPI_Pln(anOrigin->pnt(), aNorm->dir()));
}
-void addPlane(double theX, double theY, double theZ,
- std::list<std::shared_ptr<GeomAPI_Shape> >& theShapes)
-{
- std::shared_ptr<GeomAPI_Pnt> anOrigin(new GeomAPI_Pnt(0, 0, 0));
- std::shared_ptr<GeomAPI_Dir> aNormal(new GeomAPI_Dir(theX, theY, theZ));
- double aSize = Config_PropManager::integer("Sketch planes", "Size of planes", PLANE_SIZE);
- std::shared_ptr<GeomAPI_Shape> aFace = GeomAlgoAPI_FaceBuilder::square(anOrigin, aNormal,
- aSize);
- theShapes.push_back(aFace);
-}
-
-AISObjectPtr SketchPlugin_Sketch::getAISObject(AISObjectPtr thePrevious)
-{
- std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
- data()->attribute(SketchPlugin_Sketch::NORM_ID()));
-
- if (!aNorm || (aNorm->x() == 0 && aNorm->y() == 0 && aNorm->z() == 0)) {
- AISObjectPtr aAIS = thePrevious;
- if (!aAIS) {
- std::list<std::shared_ptr<GeomAPI_Shape> > aFaces;
-
- addPlane(1, 0, 0, aFaces); // YZ plane
- addPlane(0, 1, 0, aFaces); // XZ plane
- addPlane(0, 0, 1, aFaces); // XY plane
- std::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aFaces);
- aAIS = AISObjectPtr(new GeomAPI_AISObject());
- aAIS->createShape(aCompound);
-
- std::vector<int> aRGB = Config_PropManager::color("Sketch planes", "planes_color",
- SKETCH_PLANE_COLOR);
- aAIS->setColor(aRGB[0], aRGB[1], aRGB[2]);
-
- aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness",
- SKETCH_WIDTH));
- }
- return aAIS;
- }
- return AISObjectPtr();
-}
+//void addPlane(double theX, double theY, double theZ,
+// std::list<std::shared_ptr<GeomAPI_Shape> >& theShapes)
+//{
+// std::shared_ptr<GeomAPI_Pnt> anOrigin(new GeomAPI_Pnt(0, 0, 0));
+// std::shared_ptr<GeomAPI_Dir> aNormal(new GeomAPI_Dir(theX, theY, theZ));
+// double aSize = Config_PropManager::integer("Sketch planes", "Size of planes", PLANE_SIZE);
+// std::shared_ptr<GeomAPI_Shape> aFace = GeomAlgoAPI_FaceBuilder::square(anOrigin, aNormal,
+// aSize);
+// theShapes.push_back(aFace);
+//}
+
+//AISObjectPtr SketchPlugin_Sketch::getAISObject(AISObjectPtr thePrevious)
+//{
+// std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+// data()->attribute(SketchPlugin_Sketch::NORM_ID()));
+//
+// if (!aNorm || (aNorm->x() == 0 && aNorm->y() == 0 && aNorm->z() == 0)) {
+// AISObjectPtr aAIS = thePrevious;
+// if (!aAIS) {
+// std::list<std::shared_ptr<GeomAPI_Shape> > aFaces;
+//
+// addPlane(1, 0, 0, aFaces); // YZ plane
+// addPlane(0, 1, 0, aFaces); // XZ plane
+// addPlane(0, 0, 1, aFaces); // XY plane
+// std::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aFaces);
+// aAIS = AISObjectPtr(new GeomAPI_AISObject());
+// aAIS->createShape(aCompound);
+//
+// std::vector<int> aRGB = Config_PropManager::color("Sketch planes", "planes_color",
+// SKETCH_PLANE_COLOR);
+// aAIS->setColor(aRGB[0], aRGB[1], aRGB[2]);
+//
+// aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness",
+// SKETCH_WIDTH));
+// }
+// return aAIS;
+// }
+// return AISObjectPtr();
+//}
void SketchPlugin_Sketch::erase()
{
* \ingroup DataModel
* \brief Feature for creation of the new part in PartSet.
*/
-class SketchPlugin_Sketch : public ModelAPI_CompositeFeature, public GeomAPI_IPresentable
+class SketchPlugin_Sketch : public ModelAPI_CompositeFeature//, public GeomAPI_IPresentable
{
public:
/// Sketch feature kind
/// Returns the basis plane for the sketch
std::shared_ptr<GeomAPI_Pln> plane();
- virtual AISObjectPtr getAISObject(AISObjectPtr thePrevious);
+ //virtual AISObjectPtr getAISObject(AISObjectPtr thePrevious);
/// removes also all sub-sketch elements
SKETCHPLUGIN_EXPORT virtual void erase();
<!--icon=":pictures/x_point.png"-->
</feature>
<feature id="SketchPoint" title="Point" tooltip="Create a new point" icon=":icons/point.png">
- <point_selector id="PointCoordindates" title="Point" tooltip="Point"/>
+ <sketch-2dpoint_selector id="PointCoordindates" title="Point" tooltip="Point"/>
</feature>
<feature id="SketchLine" title="Line" tooltip="Create a new line" icon=":icons/line.png">
- <point_selector id="StartPoint" title="Start point" tooltip="Start point of the line" previous_feature_param="EndPoint"/>
- <point_selector id="EndPoint" title="End point" tooltip="End point of the line"/>
+ <sketch-2dpoint_selector id="StartPoint" title="Start point" tooltip="Start point of the line" previous_feature_param="EndPoint"/>
+ <sketch-2dpoint_selector id="EndPoint" title="End point" tooltip="End point of the line"/>
</feature>
<feature id="SketchCircle" title="Circle" tooltip="Create a new circle" icon=":icons/circle.png">
- <point_selector id="CircleCenter" title="Center" tooltip="Center of the circle"/>
+ <sketch-2dpoint_selector id="CircleCenter" title="Center" tooltip="Center of the circle"/>
<point2ddistance id="CircleRadius" first_point="CircleCenter" label="Radius:" min="0" step="1.0" default="0" icon=":icons/radius.png" tooltip="Set Radius">
<validator id="GeomValidators_Positive"/>
</point2ddistance>
</feature>
<feature id="SketchArc" title="Arc" tooltip="Create a new arc of a circle" icon=":icons/arc.png">
- <point_selector id="ArcCenter" title="Center" tooltip="Center of the arc"/>
- <point_selector id="ArcStartPoint" title="Start point" tooltip="Start point of the arc"/>
- <point_selector id="ArcEndPoint" title="End point" tooltip="End point of the arc"/>
+ <sketch-2dpoint_selector id="ArcCenter" title="Center" tooltip="Center of the arc"/>
+ <sketch-2dpoint_selector id="ArcStartPoint" title="Start point" tooltip="Start point of the arc"/>
+ <sketch-2dpoint_selector id="ArcEndPoint" title="End point" tooltip="End point of the arc"/>
</feature>
</group>
<feature id="SketchConstraintDistance" title="Distance" tooltip="Create constraint for the distance from a point to an object" icon=":icons/distance.png">
<label title="Select objects for distance definition. Following objects can be accepted: point, line or arc end point, center of circle or arc."/>
- <feature_or_attribute_selector id="ConstraintEntityA" label="First object" tooltip="Select point, line end point, line, center of circle or arc.">
- <validator id="SketchPlugin_ResultPoint"/>
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_or_attribute_selector>
- <feature_or_attribute_selector id="ConstraintEntityB" label="Last object" tooltip="Select point, line end point, line, center of circle or arc.">
- <validator id="SketchPlugin_ResultPoint"/>
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DistanceAttr" parameters="ConstraintEntityA"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_or_attribute_selector>
- <point_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
+ <shape_selector id="ConstraintEntityA" label="First object" tooltip="Select point, line end point, line, center of circle or arc."
+ shape_types="edge vertex"/>
+ <shape_selector id="ConstraintEntityB" label="Last object" tooltip="Select point, line end point, line, center of circle or arc."
+ shape_types="edge vertex"/>
+ <sketch-2dpoint_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
<doublevalue_editor label="Value" tooltip="Constraint value" id="ConstraintValue" default="computed" min="0">
<validator id="GeomValidators_Positive"/>
</doublevalue_editor>
<feature id="SketchConstraintLength" title="Length" tooltip="Create constraint for the given length of a line segment" icon=":icons/length.png">
<label title="Select a line on which to calculate length" tooltip="Select a line on which to calculate length"/>
- <feature_selector id="ConstraintEntityA" label="Line" tooltip="Select an line in the viewer">
- <validator id="SketchPlugin_ResultLine"/>
- </feature_selector>
- <point_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
+ <shape_selector id="ConstraintEntityA" label="Line" tooltip="Select an line in the viewer"
+ shape_types="edge" />
+ <sketch-2dpoint_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
<doublevalue_editor label="Value" tooltip="Constraint value" id="ConstraintValue" default="computed">
<validator id="GeomValidators_Positive"/>
</doublevalue_editor>
<feature id="SketchConstraintRadius" title="Radius" tooltip="Create constraint for the given radius of a circle or an arc" icon=":icons/radius_constr.png">
<label title="Select a circle or an arc on which to calculate radius" tooltip="Select a circle or an arc on which to calculate radius"/>
- <feature_selector id="ConstraintEntityA" label="Circle or Arc" tooltip="Select a circle or an arc in the viewer">
- <validator id="SketchPlugin_ResultArc"/>
- </feature_selector>
- <point_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
+ <shape_selector id="ConstraintEntityA" label="Circle or Arc" tooltip="Select a circle or an arc in the viewer"
+ shape_types="edge"/>
+ <sketch-2dpoint_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
<doublevalue_editor label="Value" tooltip="Constraint value" id="ConstraintValue" default="computed"/>
<validator id="PartSet_RadiusValidator"/>
</feature>
<feature id="SketchConstraintParallel" title="Parallel" tooltip="Create constraint defining two parallel lines" icon=":icons/parallel.png">
- <feature_selector id="ConstraintEntityA" label="First line" tooltip="Select an line in the viewer">
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_selector>
- <feature_selector id="ConstraintEntityB" label="Last line" tooltip="Select an line in the viewer">
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_selector>
- <point_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
+ <shape_selector id="ConstraintEntityA" label="First line" tooltip="Select an line in the viewer"
+ shape_types="edge" use_subshapes="true"/>
+ <shape_selector id="ConstraintEntityB" label="Last line" tooltip="Select an line in the viewer"
+ shape_types="edge" use_subshapes="true"/>
+ <sketch-2dpoint_selector id="ConstraintFlyoutValuePnt" internal="1" obligatory="0"/>
<validator id="PartSet_ParallelValidator"/>
</feature>
<feature id="SketchConstraintPerpendicular" title="Perpendicular" tooltip="Create constraint defining two perpendicular lines" icon=":icons/perpendicular.png">
- <feature_selector id="ConstraintEntityA" label="First line" tooltip="Select an line in the viewer">
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_selector>
- <feature_selector id="ConstraintEntityB" label="Last line" tooltip="Select an line in the viewer">
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_DifferentObjects"/>
- </feature_selector>
+ <shape_selector id="ConstraintEntityA" label="First line" tooltip="Select an line in the viewer"
+ shape_types="edge" use_subshapes="true"/>
+ <shape_selector id="ConstraintEntityB" label="Last line" tooltip="Select an line in the viewer"
+ shape_types="edge" use_subshapes="true"/>
<validator id="PartSet_PerpendicularValidator"/>
</feature>
<feature id="SketchConstraintRigid" title="Fixed" tooltip="Create constraint defining fixed object" icon=":icons/fixed.png">
- <feature_or_attribute_selector id="ConstraintEntityA" label="Object" tooltip="Select any object in the viewer">
- <validator id="SketchPlugin_ResultPoint"/>
- <validator id="SketchPlugin_ResultLine"/>
- <validator id="SketchPlugin_ResultArc"/>
- </feature_or_attribute_selector>
+ <shape_selector id="ConstraintEntityA" label="Object" tooltip="Select any object in the viewer"
+ shape_types="edge vertex"/>
</feature>
</group>
</workbench>
{
QMenu* aMenu = new QMenu();
XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
- QList<ObjectPtr> aObjects = aSelMgr->selection()->selectedObjects();
+ QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
int aSelected = aObjects.size();
if (aSelected > 0) {
SessionPtr aMgr = ModelAPI_Session::get();
void XGUI_ContextMenuMgr::addViewerItems(QMenu* theMenu) const
{
XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
- QList<ObjectPtr> aObjects = aSelMgr->selection()->selectedObjects();
+ QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
if (aObjects.size() > 0) {
//if (aObjects.size() == 1)
// theMenu->addAction(action("EDIT_CMD"));
}
}
+void XGUI_Displayer::activate(ObjectPtr theFeature)
+{
+ QIntList aModes;
+ activate(theFeature, aModes);
+}
+
void XGUI_Displayer::activate(ObjectPtr theObject, const QIntList& theModes)
{
if (isVisible(theObject)) {
return aModes.Extent() > 0;
}
-void XGUI_Displayer::stopSelection(const QList<ObjectPtr>& theResults, const bool isStop,
+void XGUI_Displayer::stopSelection(const QObjectPtrList& theResults, const bool isStop,
const bool isUpdateViewer)
{
Handle(AIS_InteractiveContext) aContext = AISContext();
return;
Handle(AIS_Shape) anAIS;
- QList<ObjectPtr>::const_iterator anIt = theResults.begin(), aLast = theResults.end();
+ QObjectPtrList::const_iterator anIt = theResults.begin(), aLast = theResults.end();
ObjectPtr aFeature;
for (; anIt != aLast; anIt++) {
aFeature = *anIt;
updateViewer();
}
-void XGUI_Displayer::setSelected(const QList<ObjectPtr>& theResults, const bool isUpdateViewer)
+void XGUI_Displayer::setSelected(const QObjectPtrList& theResults, const bool isUpdateViewer)
{
Handle(AIS_InteractiveContext) aContext = AISContext();
// we need to unhighligth objects manually in the current local context
if (aContext.IsNull())
return;
- QList<ObjectPtr> aRemoved;
+ QObjectPtrList aRemoved;
foreach (ObjectPtr aFeature, myResult2AISObjectMap.keys()) {
if (!aFeature || !aFeature->data() || !aFeature->data()->isValid()) {
AISObjectPtr anObj = myResult2AISObjectMap[aFeature];
return;
// Open local context if there is no one
if (!aContext->HasOpenedContext()) {
- aContext->ClearCurrents(false);
- //aContext->OpenLocalContext(false/*use displayed objects*/, true/*allow shape decomposition*/);
+ // Preserve selected objects
+ //AIS_ListOfInteractive aAisList;
+ //for (aContext->InitCurrent(); aContext->MoreCurrent(); aContext->NextCurrent())
+ // aAisList.Append(aContext->Current());
+
+ aContext->ClearCurrents();
aContext->OpenLocalContext();
aContext->NotUseDisplayedObjects();
myUseExternalObjects = false;
myActiveSelectionModes.clear();
+
+ // Restore selection
+ //AIS_ListIteratorOfListOfInteractive aIt(aAisList);
+ //for(; aIt.More(); aIt.Next()) {
+ // if (aContext->IsDisplayed(aIt.Value()))
+ // aContext->SetSelected(aIt.Value(), false);
+ //}
}
}
{
Handle(AIS_InteractiveContext) ic = AISContext();
if ( (!ic.IsNull()) && (ic->HasOpenedContext()) ) {
- ic->ClearSelected(false);
+ // Preserve selected objects
+ //AIS_ListOfInteractive aAisList;
+ //for (ic->InitSelected(); ic->MoreSelected(); ic->NextSelected())
+ // aAisList.Append(ic->SelectedInteractive());
+
+ ic->ClearSelected();
ic->CloseAllContexts(false);
// Redisplay all object if they were displayed in localContext
updateViewer();
myUseExternalObjects = false;
myActiveSelectionModes.clear();
+
+ // Restore selection
+ //AIS_ListIteratorOfListOfInteractive aIt(aAisList);
+ //for(; aIt.More(); aIt.Next()) {
+ // if (ic->IsDisplayed(aIt.Value()))
+ // ic->SetCurrentObject(aIt.Value(), false);
+ //}
}
}
/// \param theFeatures a list of features to be disabled
/// \param theToStop the boolean state whether it it stopped or non stopped
/// \param isUpdateViewer the parameter whether the viewer should be update immediatelly
- void stopSelection(const QList<ObjectPtr>& theFeatures, const bool isStop,
+ void stopSelection(const QObjectPtrList& theFeatures, const bool isStop,
const bool isUpdateViewer);
/**
* \param theFeatures a list of features to be selected
* isUpdateViewer the parameter whether the viewer should be update immediatelly
*/
- void setSelected(const QList<ObjectPtr>& theFeatures, bool isUpdateViewer = true);
+ void setSelected(const QObjectPtrList& theFeatures, bool isUpdateViewer = true);
/// Un select all objects
/// \param theModes - modes on which it has to be activated (can be empty)
void activate(ObjectPtr theFeature, const QIntList& theModes);
+ /// Activates the given object with default modes
+ void activate(ObjectPtr theFeature);
+
/// Returns true if the given object can be selected
bool isActive(ObjectPtr theObject) const;
XGUI_OperationMgr* anOperationMgr = myWorkshop->operationMgr();
connect(anOperationMgr, SIGNAL(operationStarted(ModuleBase_Operation*)),
- this, SIGNAL(operationStarted(ModuleBase_Operation*)));
+ SIGNAL(operationStarted(ModuleBase_Operation*)));
connect(anOperationMgr, SIGNAL(operationStopped(ModuleBase_Operation*)),
- this, SIGNAL(operationStopped(ModuleBase_Operation*)));
+ SIGNAL(operationStopped(ModuleBase_Operation*)));
+ connect(anOperationMgr, SIGNAL(operationResumed(ModuleBase_Operation*)),
+ SIGNAL(operationResumed(ModuleBase_Operation*)));
+ connect(anOperationMgr, SIGNAL(operationComitted(ModuleBase_Operation*)),
+ SIGNAL(operationComitted(ModuleBase_Operation*)));
+ connect(anOperationMgr, SIGNAL(operationAborted(ModuleBase_Operation*)),
+ SIGNAL(operationAborted(ModuleBase_Operation*)));
myDocumentShapeFilter = new ModuleBase_ShapeDocumentFilter(this);
}
return aDisp->getObject(theAIS);
}
-void XGUI_ModuleConnector::setSelected(const QList<ObjectPtr>& theFeatures)
+void XGUI_ModuleConnector::setSelected(const QObjectPtrList& theFeatures)
{
XGUI_Displayer* aDisp = myWorkshop->displayer();
aDisp->setSelected(theFeatures);
-}
\ No newline at end of file
+}
+
+bool XGUI_ModuleConnector::canStartOperation(QString theId)
+{
+ return myWorkshop->operationMgr()->canStartOperation(theId);
+}
//! Returns currently active operation
virtual ModuleBase_Operation* currentOperation() const;
+ //! Returns true if the operation with id theId can be started
+ virtual bool canStartOperation(QString theId);
+
//! Returns AIS opbject by data object
virtual AISObjectPtr findPresentation(const ObjectPtr& theObject) const;
//! Select features clearing previous selection.
//! If the list is empty then selection will be cleared
- virtual void setSelected(const QList<ObjectPtr>& theFeatures);
+ virtual void setSelected(const QObjectPtrList& theFeatures);
XGUI_Workshop* workshop() const { return myWorkshop; }
}
//***************************************************
-void XGUI_ObjectsBrowser::setObjectsSelected(const QList<ObjectPtr>& theObjects)
+void XGUI_ObjectsBrowser::setObjectsSelected(const QObjectPtrList& theObjects)
{
QList<QModelIndex> theIndexes;
QItemSelectionModel* aSelectModel = myTreeView->selectionModel();
virtual ~XGUI_DataTree();
//! Returns list of currently selected objects
- QList<ObjectPtr> selectedObjects() const
+ QObjectPtrList selectedObjects() const
{
return mySelectedData;
}
private:
//! List of currently selected data
- QList<ObjectPtr> mySelectedData;
+ QObjectPtrList mySelectedData;
};
/**\class XGUI_ObjectsBrowser
}
//! Returns list of currently selected objects
- QList<ObjectPtr> selectedObjects() const
+ QObjectPtrList selectedObjects() const
{
return myObjectsList;
}
- void setObjectsSelected(const QList<ObjectPtr>& theObjects);
+ void setObjectsSelected(const QObjectPtrList& theObjects);
//! Returns currently selected indexes
QModelIndexList selectedIndexes() const
QLineEdit* myActiveDocLbl;
XGUI_DataTree* myTreeView;
- QList<ObjectPtr> myObjectsList;
+ QObjectPtrList myObjectsList;
};
#endif
return !myOperations.isEmpty() && (myOperations.last() != NULL);
}
+bool XGUI_OperationMgr::hasOperation(const QString& theId) const
+{
+ foreach(ModuleBase_Operation* aOp, myOperations) {
+ if (aOp->id() == theId)
+ return true;
+ }
+ return false;
+}
+
+ModuleBase_Operation* XGUI_OperationMgr::findOperation(const QString& theId) const
+{
+ foreach(ModuleBase_Operation* aOp, myOperations) {
+ if (aOp->id() == theId)
+ return aOp;
+ }
+ return 0;
+}
+
+
int XGUI_OperationMgr::operationsCount() const
{
return myOperations.count();
bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
{
- if (!canStartOperation(theOperation))
- return false;
-
+ if (hasOperation())
+ currentOperation()->postpone();
myOperations.append(theOperation);
- connect(theOperation, SIGNAL(stopped()), this, SLOT(onOperationStopped()));
- connect(theOperation, SIGNAL(started()), this, SLOT(onOperationStarted()));
- connect(theOperation, SIGNAL(resumed()), this, SIGNAL(operationResumed()));
+ connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted()));
+ connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted()));
+ connect(theOperation, SIGNAL(committed()), SLOT(onOperationComitted()));
+ connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped()));
+ connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed()));
theOperation->start();
onValidateOperation();
theOperation->resume();
}
-bool XGUI_OperationMgr::canStartOperation(ModuleBase_Operation* theOperation)
+bool XGUI_OperationMgr::canStartOperation(QString theId)
{
bool aCanStart = true;
ModuleBase_Operation* aCurrentOp = currentOperation();
if (aCurrentOp) {
- if (!aCurrentOp->isGranted(theOperation)) {
+ if (!aCurrentOp->isGranted(theId)) {
if (canAbortOperation()) {
aCurrentOp->abort();
} else {
emit operationStarted(aSenderOperation);
}
+void XGUI_OperationMgr::onOperationAborted()
+{
+ ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ emit operationAborted(aSenderOperation);
+}
+
+void XGUI_OperationMgr::onOperationComitted()
+{
+ ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ emit operationComitted(aSenderOperation);
+}
+
+void XGUI_OperationMgr::onOperationResumed()
+{
+ ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ emit operationResumed(aSenderOperation);
+}
+
void XGUI_OperationMgr::onOperationStopped()
{
ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
isAccepted = false;
break;
}
- if(anOperation) {
- anOperation->keyReleased(theEvent->key());
- }
+ //if(anOperation) {
+ // anOperation->keyReleased(theEvent->key());
+ //}
return isAccepted;
}
/// Returns the current operation or NULL
/// \return the current operation
ModuleBase_Operation* currentOperation() const;
+
/// Check if the given operation is active operation.
/// Also, returns false is ther is no active operation.
bool isCurrentOperation(ModuleBase_Operation* theOperation);
+
/// Returns true is operation manager has at least one non-null operation.
bool hasOperation() const;
+
+ /// Returns true is operation manager has an operation with given Id.
+ bool hasOperation(const QString& theId) const;
+
+ /// Find and return operation by its Id.
+ ModuleBase_Operation* findOperation(const QString& theId) const;
+
/// Returns number of operations in the stack
int operationsCount() const;
+
/// Returns list of all operations IDs
QStringList operationList() const;
bool abortAllOperations();
+ /// Returns whether the operation can be started. Check if there is already started operation and
+ /// the granted parameter of the launched operation
+ /// \param theId id of the operation which is going to start
+ bool canStartOperation(QString theId);
+
+ bool canStopOperation();
+
+ /// Returns true if the operation can be aborted
+ bool canAbortOperation();
+
public slots:
/// Slot that commits the current operation.
void onCommitOperation();
signals:
/// Signal about an operation is started. It is emitted after the start() of operation is done.
void operationStarted(ModuleBase_Operation* theOperation);
+
/// Signal about an operation is stopped. It is emitted after the stop() of operation is done.
/// \param theOperation a stopped operation
void operationStopped(ModuleBase_Operation* theOperation);
+
/// Signal about an operation is resumed. It is emitted after the resume() of operation is done.
- void operationResumed();
+ void operationResumed(ModuleBase_Operation* theOperation);
+
+ /// Emitted when current operation is comitted
+ void operationComitted(ModuleBase_Operation* theOperation);
+
+ /// Emitted when current operation is aborted
+ void operationAborted(ModuleBase_Operation* theOperation);
+
/// Signal is emitted after the validate methods calls.
void operationValidated(bool);
/// \return the state whether the operation is resumed
void resumeOperation(ModuleBase_Operation* theOperation);
- /// Returns whether the operation can be started. Check if there is already started operation and
- /// the granted parameter of the launched operation
- /// \param theOperation an operation to check
- bool canStartOperation(ModuleBase_Operation* theOperation);
-
- bool canStopOperation();
-
- /// Returns true if the operation can be aborted
- bool canAbortOperation();
-
public slots:
/// SLOT, that is called by the key in the property panel is clicked.
/// \param theName the attribute name
/// If there is a suspended operation, restart it.
void onOperationStopped();
void onOperationStarted();
+ void onOperationAborted();
+ void onOperationComitted();
+ void onOperationResumed();
private:
typedef QList<ModuleBase_Operation*> Operations; ///< definition for a list of operations
#include <XGUI_PropertyPanel.h>
#include <XGUI_Constants.h>
-#include <ModuleBase_WidgetPoint2D.h>
#include <QWidget>
#include <QVBoxLayout>
void XGUI_PropertyPanel::cleanContent()
{
+ if (myActiveWidget)
+ myActiveWidget->deactivate();
myWidgets.clear();
qDeleteAll(myCustomWidget->children());
myActiveWidget = NULL;
void XGUI_PropertyPanel::setModelWidgets(const QList<ModuleBase_ModelWidget*>& theWidgets)
{
myWidgets = theWidgets;
- int aS = myWidgets.size();
if (theWidgets.empty()) return;
QList<ModuleBase_ModelWidget*>::const_iterator anIt = theWidgets.begin(), aLast =
connect(*anIt, SIGNAL(focusInWidget(ModuleBase_ModelWidget*)),
this, SLOT(activateWidget(ModuleBase_ModelWidget*)));
- ModuleBase_WidgetPoint2D* aPointWidget = dynamic_cast<ModuleBase_WidgetPoint2D*>(*anIt);
- if (aPointWidget)
- connect(aPointWidget, SIGNAL(storedPoint2D(ObjectPtr, const std::string&)), this,
- SIGNAL(storedPoint2D(ObjectPtr, const std::string&)));
+ //ModuleBase_WidgetPoint2D* aPointWidget = dynamic_cast<ModuleBase_WidgetPoint2D*>(*anIt);
+ //if (aPointWidget)
+ // connect(aPointWidget, SIGNAL(storedPoint2D(ObjectPtr, const std::string&)), this,
+ // SIGNAL(storedPoint2D(ObjectPtr, const std::string&)));
}
ModuleBase_ModelWidget* aLastWidget = theWidgets.last();
if (aLastWidget) {
theWidget->setHighlighted(true);
}
myActiveWidget = theWidget;
- emit widgetActivated(theWidget);
+ if (myActiveWidget)
+ emit widgetActivated(theWidget);
+ else
+ emit noMoreWidgets();
}
/// Signal about the point 2d set to the feature
/// \param the feature
/// \param the attribute of the feature
- void storedPoint2D(ObjectPtr theFeature, const std::string& theAttribute);
+ //void storedPoint2D(ObjectPtr theFeature, const std::string& theAttribute);
private:
XGUI_Displayer* aDisplayer = myWorkshop->displayer();
Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
- for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected()) {
- ModuleBase_ViewerPrs aPrs;
+ if (aContext->HasOpenedContext()) {
+ for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected()) {
+ ModuleBase_ViewerPrs aPrs;
- Handle(AIS_InteractiveObject) anIO = aContext->SelectedInteractive();
- aPrs.setInteractive(anIO);
+ Handle(AIS_InteractiveObject) anIO = aContext->SelectedInteractive();
+ aPrs.setInteractive(anIO);
- ObjectPtr aFeature = aDisplayer->getObject(anIO);
- // we should not check the appearance of this feature because there can be some selected shapes
- // for one feature
- //if (aPrsFeatures.find(aFeature) == aPrsFeatures.end()) {
+ ObjectPtr aFeature = aDisplayer->getObject(anIO);
+ // we should not check the appearance of this feature because there can be some selected shapes
+ // for one feature
+ //if (aPrsFeatures.find(aFeature) == aPrsFeatures.end()) {
aPrs.setFeature(aFeature);
- //aPrsFeatures.insert(aFeature);
- //}
- if (aContext->HasOpenedContext()) {
+ //aPrsFeatures.insert(aFeature);
+ //}
TopoDS_Shape aShape = aContext->SelectedShape();
if (!aShape.IsNull() && (aShape.ShapeType() != theShapeTypeToSkip))
aPrs.setShape(aShape);
+ Handle(SelectMgr_EntityOwner) anOwner = aContext->SelectedOwner();
+ aPrs.setOwner(anOwner);
+ aPresentations.append(aPrs);
+ }
+ } else {
+ for (aContext->InitCurrent(); aContext->MoreCurrent(); aContext->NextCurrent()) {
+ ModuleBase_ViewerPrs aPrs;
+
+ Handle(AIS_InteractiveObject) anIO = aContext->Current();
+ aPrs.setInteractive(anIO);
+
+ ObjectPtr aFeature = aDisplayer->getObject(anIO);
+ // we should not check the appearance of this feature because there can be some selected shapes
+ // for one feature
+ //if (aPrsFeatures.find(aFeature) == aPrsFeatures.end()) {
+ aPrs.setFeature(aFeature);
+ //aPrsFeatures.insert(aFeature);
+ //}
+ aPresentations.append(aPrs);
}
- Handle(SelectMgr_EntityOwner) anOwner = aContext->SelectedOwner();
- aPrs.setOwner(anOwner);
- aPresentations.append(aPrs);
}
return aPresentations;
}
return aPresentations;
}
-QList<ObjectPtr> XGUI_Selection::selectedObjects() const
+QObjectPtrList XGUI_Selection::selectedObjects() const
{
return myWorkshop->objectBrowser()->selectedObjects();
}
-QList<ObjectPtr> XGUI_Selection::selectedPresentations() const
+QObjectPtrList XGUI_Selection::selectedPresentations() const
{
- QList<ObjectPtr> aSelectedList;
+ QObjectPtrList aSelectedList;
Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected()) {
virtual QList<ModuleBase_ViewerPrs> getHighlighted(int theShapeTypeToSkip = -1) const;
/**
- * Returns list of currently selected objects
+ * Returns list of currently selected objects in object browser
*/
- virtual QList<ObjectPtr> selectedObjects() const;
+ virtual QObjectPtrList selectedObjects() const;
/**
* Returns list of currently selected results
*/
- virtual QList<ObjectPtr> selectedPresentations() const;
+ virtual QObjectPtrList selectedPresentations() const;
//! Returns list of currently selected QModelIndexes
virtual QModelIndexList selectedIndexes() const;
//**************************************************************
void XGUI_SelectionMgr::onObjectBrowserSelection()
{
- QList<ObjectPtr> aObjects = myWorkshop->objectBrowser()->selectedObjects();
+ QObjectPtrList aObjects = myWorkshop->objectBrowser()->selectedObjects();
XGUI_Displayer* aDisplayer = myWorkshop->displayer();
aDisplayer->setSelected(aObjects);
emit selectionChanged();
//**************************************************************
void XGUI_SelectionMgr::onViewerSelection()
{
- QList<ObjectPtr> aFeatures;
+ QObjectPtrList aFeatures;
Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected()) {
Handle(AIS_InteractiveObject) anIO = aContext->SelectedInteractive();
{
myEnableDrawMode = myViewer->isSelectionEnabled() && myViewer->isMultiSelectionEnabled();
}
+
+Handle(V3d_View) XGUI_ViewWindow::v3dView() const
+{
+ return myViewPort->getView();
+}
\ No newline at end of file
#include "XGUI.h"
#include "XGUI_Constants.h"
+#include <ModuleBase_IViewWindow.h>
+
#include <Qtx.h>
#include <QFrame>
#include <QLabel>
#include <QMap>
-#include <V3d_View.hxx>
-#include <V3d_Viewer.hxx>
+//#include <V3d_View.hxx>
+//#include <V3d_Viewer.hxx>
class XGUI_ViewPort;
class XGUI_Viewer;
It contains a view port object (drawing area) and toolbars for view camera and window management.
Also it managements events in view port
*/
-class XGUI_EXPORT XGUI_ViewWindow : public QFrame
+class XGUI_EXPORT XGUI_ViewWindow : public QFrame, public ModuleBase_IViewWindow
{
Q_OBJECT
public:
//! Updates drawing mode in the view window
void updateEnabledDrawMode();
+ /// Returns OCCT object which contains 3d view object
+ virtual Handle(V3d_View) v3dView() const;
+
signals:
//! Emited whien view transformation operation is started
void vpTransformationStarted(XGUI_ViewWindow::OperationType type);
XGUI_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
connect(aViewer, SIGNAL(lastViewClosed()), this, SIGNAL(lastViewClosed()));
- connect(aViewer, SIGNAL(tryCloseView(XGUI_ViewWindow*)), this, SIGNAL(tryCloseView()));
- connect(aViewer, SIGNAL(deleteView(XGUI_ViewWindow*)), this, SIGNAL(deleteView()));
- connect(aViewer, SIGNAL(viewCreated(XGUI_ViewWindow*)), this, SIGNAL(viewCreated()));
- connect(aViewer, SIGNAL(activated(XGUI_ViewWindow*)), this, SIGNAL(activated()));
+
+ connect(aViewer, SIGNAL(tryCloseView(XGUI_ViewWindow*)),
+ this, SLOT(onTryCloseView(XGUI_ViewWindow*)));
+
+ connect(aViewer, SIGNAL(deleteView(XGUI_ViewWindow*)),
+ this, SLOT(onDeleteView(XGUI_ViewWindow*)));
+
+ connect(aViewer, SIGNAL(viewCreated(XGUI_ViewWindow*)),
+ this, SLOT(onViewCreated(XGUI_ViewWindow*)));
+
+ connect(aViewer, SIGNAL(activated(XGUI_ViewWindow*)),
+ this, SLOT(onActivated(XGUI_ViewWindow*)));
connect(aViewer, SIGNAL(mousePress(XGUI_ViewWindow*, QMouseEvent*)), this,
SLOT(onMousePress(XGUI_ViewWindow*, QMouseEvent*)));
+
connect(aViewer, SIGNAL(mouseRelease(XGUI_ViewWindow*, QMouseEvent*)), this,
SLOT(onMouseRelease(XGUI_ViewWindow*, QMouseEvent*)));
+
connect(aViewer, SIGNAL(mouseDoubleClick(XGUI_ViewWindow*, QMouseEvent*)), this,
SLOT(onMouseDoubleClick(XGUI_ViewWindow*, QMouseEvent*)));
+
connect(aViewer, SIGNAL(mouseMove(XGUI_ViewWindow*, QMouseEvent*)), this,
SLOT(onMouseMove(XGUI_ViewWindow*, QMouseEvent*)));
+
connect(aViewer, SIGNAL(keyPress(XGUI_ViewWindow*, QKeyEvent*)), this,
SLOT(onKeyPress(XGUI_ViewWindow*, QKeyEvent*)));
+
connect(aViewer, SIGNAL(keyRelease(XGUI_ViewWindow*, QKeyEvent*)), this,
SLOT(onKeyRelease(XGUI_ViewWindow*, QKeyEvent*)));
}
}
-void XGUI_ViewerProxy::onMousePress(XGUI_ViewWindow*, QMouseEvent* theEvent)
+
+void XGUI_ViewerProxy::onTryCloseView(XGUI_ViewWindow* theWnd)
+{
+ emit tryCloseView(theWnd);
+}
+
+void XGUI_ViewerProxy::onDeleteView(XGUI_ViewWindow* theWnd)
+{
+ emit deleteView(theWnd);
+}
+
+void XGUI_ViewerProxy::onViewCreated(XGUI_ViewWindow* theWnd)
+{
+ emit viewCreated(theWnd);
+}
+
+void XGUI_ViewerProxy::onActivated(XGUI_ViewWindow* theWnd)
+{
+ emit activated(theWnd);
+}
+
+void XGUI_ViewerProxy::onMousePress(XGUI_ViewWindow* theWnd, QMouseEvent* theEvent)
{
- emit mousePress(theEvent);
+ emit mousePress(theWnd, theEvent);
}
-void XGUI_ViewerProxy::onMouseRelease(XGUI_ViewWindow*, QMouseEvent* theEvent)
+void XGUI_ViewerProxy::onMouseRelease(XGUI_ViewWindow* theWnd, QMouseEvent* theEvent)
{
- emit mouseRelease(theEvent);
+ emit mouseRelease(theWnd, theEvent);
}
-void XGUI_ViewerProxy::onMouseDoubleClick(XGUI_ViewWindow*, QMouseEvent* theEvent)
+void XGUI_ViewerProxy::onMouseDoubleClick(XGUI_ViewWindow* theWnd, QMouseEvent* theEvent)
{
- emit mouseDoubleClick(theEvent);
+ emit mouseDoubleClick(theWnd, theEvent);
}
-void XGUI_ViewerProxy::onMouseMove(XGUI_ViewWindow*, QMouseEvent* theEvent)
+void XGUI_ViewerProxy::onMouseMove(XGUI_ViewWindow* theWnd, QMouseEvent* theEvent)
{
- emit mouseMove(theEvent);
+ emit mouseMove(theWnd, theEvent);
}
-void XGUI_ViewerProxy::onKeyPress(XGUI_ViewWindow*, QKeyEvent* theEvent)
+void XGUI_ViewerProxy::onKeyPress(XGUI_ViewWindow* theWnd, QKeyEvent* theEvent)
{
- emit keyPress(theEvent);
+ emit keyPress(theWnd, theEvent);
}
-void XGUI_ViewerProxy::onKeyRelease(XGUI_ViewWindow*, QKeyEvent* theEvent)
+void XGUI_ViewerProxy::onKeyRelease(XGUI_ViewWindow* theWnd, QKeyEvent* theEvent)
{
- emit keyRelease(theEvent);
+ emit keyRelease(theWnd, theEvent);
}
+
+
//***************************************
void XGUI_ViewerProxy::enableSelection(bool isEnabled)
{
/// Remove all selection filters from the viewer
virtual void clearSelectionFilters();
- private slots:
+private slots:
+ void onTryCloseView(XGUI_ViewWindow*);
+ void onDeleteView(XGUI_ViewWindow*);
+ void onViewCreated(XGUI_ViewWindow*);
+ void onActivated(XGUI_ViewWindow*);
+
void onMousePress(XGUI_ViewWindow*, QMouseEvent*);
void onMouseRelease(XGUI_ViewWindow*, QMouseEvent*);
void onMouseDoubleClick(XGUI_ViewWindow*, QMouseEvent*);
void onMouseMove(XGUI_ViewWindow*, QMouseEvent*);
+
void onKeyPress(XGUI_ViewWindow*, QKeyEvent*);
void onKeyRelease(XGUI_ViewWindow*, QKeyEvent*);
connect(myOperationMgr, SIGNAL(operationStarted(ModuleBase_Operation*)),
SLOT(onOperationStarted()));
- connect(myOperationMgr, SIGNAL(operationResumed()), SLOT(onOperationStarted()));
+ connect(myOperationMgr, SIGNAL(operationResumed(ModuleBase_Operation*)), SLOT(onOperationStarted()));
connect(myOperationMgr, SIGNAL(operationStopped(ModuleBase_Operation*)),
SLOT(onOperationStopped(ModuleBase_Operation*)));
connect(myMainWindow, SIGNAL(exitKeySequence()), SLOT(onExit()));
std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
- QList<ObjectPtr> aList;
+ QObjectPtrList aList;
std::set<ObjectPtr>::const_iterator aIt;
for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
aList.append(*aIt);
std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
- QList<ObjectPtr> aList;
+ QObjectPtrList aList;
std::set<ObjectPtr>::const_iterator aIt;
for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
aList.append(*aIt);
{
std::set<ObjectPtr> aObjects = theMsg->objects();
std::set<ObjectPtr>::const_iterator aIt;
- QIntList aModes;
for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
ObjectPtr aObj = (*aIt);
bool aHide = !aObj->data() || !aObj->data()->isValid();
myDisplayer->display(aObj, false); // In order to update presentation
if (myOperationMgr->hasOperation()) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
- if (!aOperation->hasObject(aObj))
- if (!myDisplayer->isActive(aObj))
- myDisplayer->activate(aObj, aModes);
+ if (aOperation->hasObject(aObj) && myDisplayer->isActive(aObj))
+ myDisplayer->deactivate(aObj);
}
} else {
if (myOperationMgr->hasOperation()) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
// Display only current operation results if operation has preview
- if (aOperation->hasObject(aObj) && aOperation->hasPreview()) {
+ if (aOperation->hasObject(aObj)/* && aOperation->hasPreview()*/) {
myDisplayer->display(aObj, false);
// Deactivate object of current operation from selection
if (myDisplayer->isActive(aObj))
}
}
- aOperation->setPropertyPanel(myPropertyPanel);
myPropertyPanel->setModelWidgets(aWidgets);
- if (!aOperation->activateByPreselection())
- myPropertyPanel->activateNextWidget(NULL);
+ aOperation->setPropertyPanel(myPropertyPanel);
+ // Do not activate widgets by default if the current operation is editing operation
+ // Because we don't know which widget is going to be edited.
+ if ((!aOperation->isEditOperation())) {
+ if (!aOperation->activateByPreselection())
+ myPropertyPanel->activateNextWidget(NULL);
+ }
+ // Set final definitions if they are necessary
+ myModule->propertyPanelDefined(aOperation);
+
// 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)) {
updateCommandStatus();
hidePropertyPanel();
myPropertyPanel->cleanContent();
+
+ // Activate objects created by current operation
+ FeaturePtr aFeature = theOperation->feature();
+ myDisplayer->activate(aFeature);
+ const std::list<ResultPtr>& aResults = aFeature->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+ myDisplayer->activate(*aIt);
+ }
}
bool XGUI_Workshop::event(QEvent * theEvent)
salomeConnector()->setDocumentKind(aFeatureId, QString::fromStdString(theMessage->documentKind()));
myActionsMgr->addCommand(aAction);
- myModule->featureCreated(aAction);
+ myModule->actionCreated(aAction);
} else {
XGUI_MainMenu* aMenuBar = myMainWindow->menuObject();
isUsePropPanel);
aCommand->setNestedCommands(aNestedFeatures.split(" ", QString::SkipEmptyParts));
myActionsMgr->addCommand(aCommand);
- myModule->featureCreated(aCommand);
+ myModule->actionCreated(aCommand);
}
}
//**************************************************************
void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
{
- QList<ObjectPtr> aObjects = mySelector->selection()->selectedObjects();
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
if ((theId == "ACTIVATE_PART_CMD") && (aObjects.size() > 0)) {
ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObjects.first());
activatePart(aPart);
setDisplayMode(aObjects, XGUI_Displayer::Wireframe);
else if (theId == "HIDEALL_CMD")
myDisplayer->eraseAll();
+ else if (theId == "EDIT_CMD") {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObjects.first());
+ if (aFeature)
+ myModule->editFeature(aFeature);
+ }
}
//**************************************************************
}
//**************************************************************
-void XGUI_Workshop::deleteObjects(const QList<ObjectPtr>& theList)
+void XGUI_Workshop::deleteObjects(const QObjectPtrList& theList)
{
QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
QMessageBox::StandardButton aRes = QMessageBox::warning(
}
//**************************************************************
-void XGUI_Workshop::showObjects(const QList<ObjectPtr>& theList, bool isVisible)
+void XGUI_Workshop::showObjects(const QObjectPtrList& theList, bool isVisible)
{
foreach (ObjectPtr aObj, theList)
{
}
//**************************************************************
-void XGUI_Workshop::showOnlyObjects(const QList<ObjectPtr>& theList)
+void XGUI_Workshop::showOnlyObjects(const QObjectPtrList& theList)
{
myDisplayer->eraseAll(false);
showObjects(theList, true);
}
//**************************************************************
-void XGUI_Workshop::setDisplayMode(const QList<ObjectPtr>& theList, int theMode)
+void XGUI_Workshop::setDisplayMode(const QObjectPtrList& theList, int theMode)
{
foreach(ObjectPtr aObj, theList) {
myDisplayer->setDisplayMode(aObj, (XGUI_Displayer::DisplayMode)theMode, false);
void activatePart(std::shared_ptr<ModelAPI_ResultPart> theFeature);
//! Delete features
- void deleteObjects(const QList<ObjectPtr>& theList);
+ void deleteObjects(const QObjectPtrList& theList);
//! Show the given features in 3d Viewer
- void showObjects(const QList<ObjectPtr>& theList, bool isVisible);
+ void showObjects(const QObjectPtrList& theList, bool isVisible);
//! Show the given features in 3d Viewer
- void showOnlyObjects(const QList<ObjectPtr>& theList);
+ void showOnlyObjects(const QObjectPtrList& theList);
- void setDisplayMode(const QList<ObjectPtr>& theList, int theMode);
+ void setDisplayMode(const QObjectPtrList& theList, int theMode);
ModuleBase_IModule* module() const
{
/// SLOT, that is called after the operation is started. Update workshop state according to
/// the started operation, e.g. visualizes the property panel and connect to it.
void onOperationStarted();
+
/// SLOT, that is called after the operation is stopped. Update workshop state, e.g.
/// hides the property panel and udpate the command status.
/// \param theOpertion a stopped operation
