{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a workshop object instance
+ /// \param theId an Id of a feature
+ /// \param theDescription an XML description of the feature
ModuleBase_Dialog(ModuleBase_IWorkshop* theParent, const QString& theId,
const std::string& theDescription);
+ /// Redefinition of virtual method
virtual void accept();
protected:
+ /// Redefinition of virtual method
virtual void showEvent(QShowEvent* theEvent);
private:
+ /// Initialising of the widget
void initializeWidget(ModuleBase_ModelWidget* theWidget);
+ /// Id of the feature
QString myId;
+
+ /// XML description of the feature
std::string myDescription;
+
+ /// An instance of workshop object
ModuleBase_IWorkshop* myWorkshop;
+
+ /// The feature instance
FeaturePtr myFeature;
+
+ /// List of created widgets
QList<ModuleBase_ModelWidget*> myWidgets;
+
+ /// Pointer on active widget
ModuleBase_ModelWidget* myActiveWidget;
};
signals:
/// The signal about key release on the control, that corresponds to the attribute
- /// \param theEvent key release event
void enterReleased();
protected slots:
/// Remove default selection filters of the module from the current viewer\r
virtual void deactivateSelectionFilters() {};\r
\r
- // Stores the current selection\r
+ /// Stores the current selection\r
virtual void storeSelection() {};\r
\r
- // Restores the current selection\r
+ /// Restores the current selection\r
virtual void restoreSelection() {};\r
\r
/// Reads description of features from XML file \r
\r
/// Add menu items for viewer into the actions map\r
/// \param theStdActions a map of standard actions\r
+ /// \param theParent a parent widget\r
/// \param theMenuActions map of action/menu for the desirable index in the viewer menu\r
/// \return true if items are added and there is no necessity to provide standard menu\r
virtual bool addViewerMenu(const QMap<QString, QAction*>& theStdActions,\r
virtual void activeSelectionModes(QIntList& theModes) {}\r
\r
/// Activate custom presentation for the object. Default realization is empty.\r
- /// \param theObject an object instance\r
+ /// \param theFeature a feature instance\r
/// \param theFlag a flag of level of customization, which means that only part of sub-elements\r
/// \param theUpdateViewer the parameter whether the viewer should be update immediately\r
virtual void activateCustomPrs(const FeaturePtr& theFeature,\r
//! Returns Vsd_View object from currently active view window
virtual Handle(V3d_View) activeView() const = 0;
+ //! Returns currently active view port widget
virtual QWidget* activeViewPort() const = 0;
//! Enable or disable selection in the viewer
/// Returns a container of possible page types, which this creator can process
/// The default implementation is empty
- /// \param a list of type names
+ /// \param theTypes a list of type names
virtual void pageTypes(std::set<std::string>& theTypes) {}
/// Returns a container of possible widget types, which this creator can process
- /// \param a list of type names
+ /// \param theTypes a list of type names
virtual void widgetTypes(std::set<std::string>& theTypes) {}
/// Create panel control by its type.
/// The default implementation is empty
/// \param theType a type
/// \param theParent a parent widget
- /// \param theData a low-level API for reading xml definitions of widgets
+ /// \param theWidgetApi a low-level API for reading xml definitions of widgets
virtual ModuleBase_PageBase* createPageByType(const std::string& theType,
QWidget* theParent,
Config_WidgetAPI* theWidgetApi);
/// The default implementation is empty
/// \param theType a type
/// \param theParent a parent widget
- /// \param theData a low-level API for reading xml definitions of widgets
+ /// \param theWidgetApi a low-level API for reading xml definitions of widgets
+ /// \param theWorkshop a workshop class instance
virtual ModuleBase_ModelWidget* createWidgetByType(const std::string& theType,
QWidget* theParent,
Config_WidgetAPI* theWidgetApi,
/// Update of commands status
virtual void updateCommandStatus() = 0;
+ /// Returns feature info according to given feature ID
+ /// \param theId a feature Id
virtual std::shared_ptr<Config_FeatureMessage> featureInfo(const QString& theId) const = 0;
+ /// Returns main window of the application
virtual QMainWindow* desktop() const = 0;
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent widget
explicit ModuleBase_IntSpinBox(QWidget* theParent = 0);
virtual ~ModuleBase_IntSpinBox() {};
/// Constructor
/// \param theParent the parent object
/// \param theData the widget configuration. The attribute of the model widget is obtained from
- /// \param theData a low-level API for reading xml definitions of widgets
+ /// a low-level API for reading xml definitions of widgets
ModuleBase_ModelWidget(QWidget* theParent, const Config_WidgetAPI* theData);
/// Destructor
virtual ~ModuleBase_ModelWidget()
void onWidgetValuesModified();
protected:
- ModuleBase_WidgetValidator* myWidgetValidator; /// own validator, by default it is zero
+ /// own validator, by default it is zero
+ ModuleBase_WidgetValidator* myWidgetValidator;
/// The attribute name of the model feature
std::string myAttributeID;
/// \param theProp a property panel instance
virtual void setPropertyPanel(ModuleBase_IPropertyPanel* theProp);
- /// \return Currently installed property panel
+ // \return Currently installed property panel
//ModuleBase_IPropertyPanel* propertyPanel() const { return myPropertyPanel; }
/// Activates widgets by preselection if it is accepted.
- /// \param theGreeAttributeId a greed attribute id if there is in the current feature
+ /// \param theGreedAttributeId a greed attribute id if there is in the current feature
/// \return last filled widget
virtual ModuleBase_ModelWidget* activateByPreselection(const std::string& theGreedAttributeId);
The value is initially set to 0.00.
\param theParent a parent object
- \param thePrecision a precision of values display
*/
explicit ModuleBase_ParamIntSpinBox(QWidget* theParent = 0);
virtual ~ModuleBase_ParamIntSpinBox();
virtual void stepBy(int);
+ /// Convert Int value from text string
virtual int valueFromText(const QString&) const;
- virtual QString textFromValue(int value) const;
+ /// Convert text string from int value
+ virtual QString textFromValue(int) const;
+
+ /// Validate the value
virtual QValidator::State validate(QString&, int&) const;
+ /// Set current int value
virtual void setValue(int);
+ /// Set current text value
virtual void setText(const QString&);
/// Set a flag about accepted variable
class ModuleBase_BRepOwner: public StdSelect_BRepOwner
{
public:
+ /// Constructor
+ /// \param aShape an owner shape
+ /// \param aPriority drawig priority
+ /// \param ComesFromDecomposition decomposition flag
ModuleBase_BRepOwner(const TopoDS_Shape& aShape,
const Standard_Integer aPriority = 0,
const Standard_Boolean ComesFromDecomposition = Standard_False)
: StdSelect_BRepOwner(aShape, aPriority, ComesFromDecomposition) {}
+ /// Highlight the presentation with the given color
+ /// \param aPM a presentations manager
+ /// \param aCol a color
+ /// \param aMode a drawing mode
virtual void HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& aPM,
const Quantity_NameOfColor aCol, const Standard_Integer aMode = 0)
{ Selectable()->HilightOwnerWithColor(aPM, aCol, this); }
ModuleBase_WidgetCheckGroupBox(QWidget* theParent, const Config_WidgetAPI* theData);
virtual ~ModuleBase_WidgetCheckGroupBox();
+ /// Set the title of the group box
+ /// \param theTitle the text of the title
void setTitle(const QString& theTitle);
/// Methods to be redefined from ModuleBase_PageBase: start
QString getPropertyPanelTitle(int theIndex);
signals:
+ /// Segnal about selected item
+ /// \param theWidget selected widget
+ /// \param theIndex selected index
void itemSelected(ModuleBase_ModelWidget* theWidget, int theIndex);
protected:
class MODULEBASE_EXPORT ModuleBase_WidgetCreatorFactory
{
public:
- // Returns an singular instance of the class if it exists or create it
+ /// Returns an singular instance of the class if it exists or create it
static std::shared_ptr<ModuleBase_WidgetCreatorFactory> get();
/// Destructor
/// Create page by its type
/// \param theType a type
/// \param theParent a parent widget
+ /// \param theWidgetApi the widget configuration. The attribute of the model widget is obtained from XML
/// \return a created page or null
ModuleBase_PageBase* createPageByType(const std::string& theType,
QWidget* theParent,
/// Create widget by its type
/// \param theType a type
/// \param theParent a parent widget
+ /// \param theWidgetApi the widget configuration. The attribute of the model widget is obtained from XML
+ /// \param theWorkshop a workshop object instance
/// \return a created widget or null
ModuleBase_ModelWidget* createWidgetByType(const std::string& theType,
QWidget* theParent,
/// \return true if the editor value is accepted
bool showPopupEditor(const bool theSendSignals = true);
+ /// Set current cursor position
+ /// \param theX the X coordinate
+ /// \param theY the Y coordinate
void setCursorPosition(const int theX, const int theY);
private:
/// Constructor
/// \param theParent the parent object
/// \param theData the widget configuration.
- /// \param theParentId is Id of a parent of the current attribute
/// \param thePlaceHolder a placeholder string
ModuleBase_WidgetExprEditor( QWidget* theParent,
const Config_WidgetAPI* theData,
/// Creates content widget for property panel
/// \param thePage a parent page
+ /// \param alignToTop align to top flag (true by default)
void createWidget(ModuleBase_PageBase* thePage, bool alignToTop = true);
/// Creates property panel content for the feature
void createPanel(ModuleBase_PageBase* thePage, const FeaturePtr& theFeature);
/// Creates one widget for property panel for the widget with given index
- /// \param theParent a parent widget
+ /// \param thePage a parent widget
/// \param theWidgetId a widget index
void createWidget(ModuleBase_PageBase* thePage,
const std::string& theWidgetId);
/// Provides correspondance between Result object and its shape
typedef QPair<ResultPtr, GeomShapePtr> GeomSelection;
- /// An action for pop-up menu in a list control
+ /// A copy action for pop-up menu in a list control
QAction* myCopyAction;
+
+ /// A delete action for pop-up menu in a list control
QAction* myDeleteAction;
/// A flag to store use_choice parameter state
//----------- Class members -------------
/// Returns a name in the next form: attribute_feature_name/attribute_id
/// \param theAttribute a model attribute
+ /// \param theWorkshop a workshop class instance
/// \return string value
- static std::string generateName(const AttributePtr& theAttribite,
+ static std::string generateName(const AttributePtr& theAttribute,
ModuleBase_IWorkshop* theWorkshop);
};
/// to current attribute by setting the value inside and calling validators. After this,
/// the previous attribute value is restored.The valid/invalid value is cashed.
/// \param theValue a selected presentation in the view
+ /// \param theAttribute the attribute
/// \return a boolean value
bool isValidSelectionForAttribute(const std::shared_ptr<ModuleBase_ViewerPrs>& theValue,
const AttributePtr& theAttribute);
/// Block the model flush of update and intialization of attribute
/// \param theAttribute an attribute of blocking
/// \param theToBlock flag whether the model is blocked or unblocked
- /// \param isActive out value if model is blocked, in value if model is unblocked
+ /// \param isFlushesActived out value if model is blocked, in value if model is unblocked
/// to be used to restore flush state when unblocked
/// \param isAttributeSetInitializedBlocked out value if model is blocked
/// in value if model is unblocked to be used to restore previous state when unblocked
ModuleBase_ModelWidget* myModelWidget; ///< the current widget to be validated
ModuleBase_IWorkshop* myWorkshop; ///< the active workshop
- QList<std::shared_ptr<ModuleBase_ViewerPrs>> myValidPrs; /// cash of valid selection presentations
- QList<std::shared_ptr<ModuleBase_ViewerPrs>> myInvalidPrs; /// cash of invalid selection presentations
+ QList<std::shared_ptr<ModuleBase_ViewerPrs>> myValidPrs; ///< cash of valid selection presentations
+ QList<std::shared_ptr<ModuleBase_ViewerPrs>> myInvalidPrs; ///< cash of invalid selection presentations
};
#endif /* ModuleBase_WidgetValidator_H_ */
ParametersPlugin_WidgetCreator();
/// Returns a container of possible widget types, which this creator can process
- /// \param a list of type names
+ /// \param theTypes a list of type names
virtual void widgetTypes(std::set<std::string>& theTypes);
/// Create widget by its type
/// The default implementation is empty
/// \param theType a type
/// \param theParent a parent widget
- /// \param theData a low-level API for reading xml definitions of widgets
+ /// \param theWidgetApi a low-level API for reading xml definitions of widgets
/// \param theWorkshop a current workshop
/// \return a created model widget or null
virtual ModuleBase_ModelWidget* createWidgetByType(const std::string& theType,
QWidget* theParent,
Config_WidgetAPI* theWidgetApi,
- ModuleBase_IWorkshop* /*theWorkshop*/);
+ ModuleBase_IWorkshop* theWorkshop);
};
#endif
const char* NoValue = "<NoValue>";
const char* NotValid = "<NotValid>";
+/*!
+ * \ingroup GUI
+ * ItemDelegate object in order to redefine items behavior
+ */
class ParametersPlugin_ItemDelegate : public QStyledItemDelegate
{
public:
+ /// Constructor
+ /// \param thaParent a parent
ParametersPlugin_ItemDelegate(QObject* thaParent) :
QStyledItemDelegate(thaParent) {}
+ /// Redefinition of virtual method
+ /// \param painter a painter object
+ /// \param option the item options
+ /// \param index the current index
virtual void paint(QPainter* painter,
const QStyleOptionViewItem& option,
const QModelIndex& index ) const;
+ /// Redefinition of virtual method
+ /// \param parent a parent widget
+ /// \param option the item options
+ /// \param index the current index
virtual QWidget* createEditor(QWidget* parent,
const QStyleOptionViewItem& option,
const QModelIndex& index) const;
+ /// Returns True if the given index is editable item
+ /// \param theIndex an item index
bool isEditable(const QModelIndex& theIndex) const;
+ /// Returns currently editing index
QModelIndex editIndex() const { return myEditingIdx; }
private:
class QToolButton;
+/*!
+ * \ingroup GUI
+ * Redefinition of QTreeWidget for processing of closeEditor event
+ */
class ParametersPlugin_TreeWidget: public QTreeWidget
{
Q_OBJECT
public:
+ /// Constructor
+ /// \param theParent a parent widget
ParametersPlugin_TreeWidget(QWidget* theParent = 0) : QTreeWidget(theParent) {}
protected slots:
+ /// Redefinition of virtual method
+ /// \param theEditor a editor widget
+ /// \param theHint end of editing hint
virtual void closeEditor(QWidget* theEditor, QAbstractItemDelegate::EndEditHint theHint);
};
void onEdit(bool);
protected:
- bool eventFilter(QObject* theObj, QEvent* theEvent);
+ /// Redefinition of virtual method
+ /// \param theObj an object
+ /// \param theEvent an event
+ virtual bool eventFilter(QObject* theObj, QEvent* theEvent);
private:
/// Returns true if the current operation is sketch entity create operation
/// Add menu items for viewer into the actions map
/// \param theStdActions a map of standard actions
+ /// \param theParent a parent widget
/// \param theMenuActions map of action/menu for the desirable index in the viewer menu
/// \return true if items are added and there is no necessity to provide standard menu
virtual bool addViewerMenu(const QMap<QString, QAction*>& theStdActions,
virtual ~PartSet_OverconstraintListener() {};
- /// Set erroneous color for the presentation of object if the object is in the conflicting list
- /// \param theObject an object to be settled
- /// \param theUpdateViewer a boolean state whether the current viewer should be updated
+ // Set erroneous color for the presentation of object if the object is in the conflicting list
+ // \param theObject an object to be settled
+ // \param theUpdateViewer a boolean state whether the current viewer should be updated
//bool customizeObject(ObjectPtr theObject, const bool theUpdateViewer);
/// Returns true if the object belongs to internal container of conflicting objects
static bool hasVisualizedSketch(ModuleBase_IWorkshop* theWorkshop);
/// Returns if the preview was displayed
- /// \param theWorkshop the application workshop
/// \return boolean value
bool isPreviewDisplayed() const { return myPreviewDisplayed; }
public:
/// Constructor
- /// \param theParent a parent object
+ /// \param theWorkshop a workshop instance
PartSet_SketcherReetntrantMgr(ModuleBase_IWorkshop* theWorkshop);
virtual ~PartSet_SketcherReetntrantMgr();
* Gets all references to the feature, take coincidence constraint features, get point 2d attributes
* and compare the point value to be equal with the given. Returns the first feature, which has
* equal points.
- * \param theSearchInResults a flag whether the conicidence feature shoudl be searched in
- * references of the feature results.
+ * \param theFeature the coincidence feature
+ * \param thePoint a 2d point
* \return the coincidence feature or null
*/
static FeaturePtr findFirstCoincidence(const FeaturePtr& theFeature,
* Returns list of features connected in a councedence feature point
* \param theStartCoin the coincidence feature
* \param theList a list which collects lines features
+ * \param theCoincidencies a list of coincidence features
* \param theAttr the attribute name
*/
static void findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList,
/// Creates a backup of the current values of the attribute
/// It should be realized in the specific widget because of different
/// parameters of the current attribute
+ /// \param theAttribute an attribute
/// \param theValid a boolean flag, if restore happens for valid parameters
virtual void restoreAttributeValue(const AttributePtr& theAttribute, const bool theValid);
/// Reference to sketch
CompositeFeaturePtr mySketch;
- bool myValueIsCashed; /// boolean state if the value is cashed during value state change
- bool myIsFeatureVisibleInCash; /// boolean value if the feature was visible when cash if filled
- double myValueInCash; /// the cashed X value during value state change
+ bool myValueIsCashed; ///< boolean state if the value is cashed during value state change
+ bool myIsFeatureVisibleInCash; ///< boolean value if the feature was visible when cash if filled
+ double myValueInCash; ///< the cashed X value during value state change
};
#endif
/// Creates a backup of the current values of the attribute
/// It should be realized in the specific widget because of different
/// parameters of the current attribute
+ /// \param theAttribute an attribute
/// \param theValid a boolean flag, if restore happens for valid parameters
void restoreAttributeValue(const AttributePtr& theAttribute, const bool theValid);
/// Pointer to a sketch
CompositeFeaturePtr mySketch;
- bool myUseSketchPlane; /// state whether the sketch plane filter should be switched on
+ bool myUseSketchPlane; ///< state whether the sketch plane filter should be switched on
};
#endif
\ No newline at end of file
virtual void setHighlighted(bool) { /*do nothing*/ };
virtual void enableFocusProcessing();
+ /// Returns True if the selected presentation can be used for plane definition
+ /// \param thePrs a presentation
static bool canFillSketch(const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs);
+ /// Set sketch plane from selected object
+ /// \param theFeature a feature of sketch
+ /// \param thePrs a presentation
static bool fillSketchPlaneBySelection(const FeaturePtr& theFeature,
const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs);
/// Block the model flush of update and intialization of attribute
/// In additional to curstom realization it blocks initialization for all feature attributes
/// as the current attribute is selection but its modification leads to other attributes change
+ /// \param theAttribute an attribute
/// \param theToBlock flag whether the model is blocked or unblocked
- /// \param isActive out value if model is blocked, in value if model is unblocked
+ /// \param isFlushesActived out value if model is blocked, in value if model is unblocked
/// to be used to restore flush state when unblocked
/// \param isAttributeSetInitializedBlocked out value if model is blocked
/// in value if model is unblocked to be used to restore previous state when unblocked
protected:
- XGUI_Workshop* myWorkshop; /// the current workshop
+ XGUI_Workshop* myWorkshop; ///< the current workshop
};
#endif
void setXMLReader(Config_DataModelReader* theReader) { myXMLReader = theReader; }
signals:
+ /// Signal about tree had been rebuilt
void treeRebuilt();
private:
/// \param theDisplayer a displayer
/// \param theObject an object
/// \return a boolean value
- static bool isVisible(XGUI_Displayer* theDislayer, const ObjectPtr& theObject);
+ static bool isVisible(XGUI_Displayer* theDisplayer, const ObjectPtr& theObject);
signals:
/// Signal on object display
/// Number of blocking of the viewer update. The viewer is updated only if it equals zero
int myViewerBlockedRecursiveCount;
- // Flag: use trihedgon for selection or not
+ /// Flag: use trihedgon for selection or not
bool myIsTrihedronActive;
/// A flag that update was requested but not done
{
public:
/// Constructor
- /// \param the current workshop
+ /// \param theWorkshop the current workshop
XGUI_EXPORT XGUI_MenuMgr(XGUI_Workshop* theWorkshop);
XGUI_EXPORT virtual ~XGUI_MenuMgr() {}
+ /// Creates feature actions
XGUI_EXPORT void createFeatureActions();
/// Redefinition of Events_Listener method
+ /// \param theMessage a message
XGUI_EXPORT virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
protected:
const std::string& theWchName, const bool aUseSeparator) const;
private:
- XGUI_Workshop* myWorkshop; /// the current workshop
- std::list< std::shared_ptr<XGUI_MenuWorkbench> > myWorkbenches; /// container of existing workbenchs
+ XGUI_Workshop* myWorkshop; ///< the current workshop
+ std::list< std::shared_ptr<XGUI_MenuWorkbench> > myWorkbenches; ///< container of existing workbenchs
};
#endif /* XGUI_MENUMGR_H_ */
/// Resets the object browser into initial state
void clearContent();
+ /// Set XML reader object for data model
+ /// \param theReader the reader object
void setXMLReader(Config_DataModelReader* theReader);
public slots:
/// Redefinition of virtual function
/// \param theObject a sender of the event
+ /// \param theEvent the event
virtual bool eventFilter(QObject *theObject, QEvent *theEvent);
/// Start the operation and append it to the stack of operations
/// \param theWidget a widget where focus in event happened
void onFocusInWidget(ModuleBase_ModelWidget* theWidget);
+
+ /// Activate next widget
+ /// \param theWidget the current widget
void onActivateNextWidget(ModuleBase_ModelWidget* theWidget);
signals:
void clearSelection();
/// Updates selection, which are depend on the selection in the given place
- /// \thePlace a widget where selection has happened.
+ /// \param thePlace a widget where selection has happened.
void updateSelectionBy(const ModuleBase_ISelection::SelectionPlace& thePlace);
signals:
//! Delete features. Delete the referenced features. There can be a question with a list of
//! referenced objects.
- //! \param theList an objects to be deleted
+ //! \param theFeatures a list of objects to be deleted
//! \param theIgnoredFeatures a list of features to be ignored during delete
bool deleteFeatures(const QObjectPtrList& theFeatures,
const std::set<FeaturePtr>& theIgnoredFeatures = std::set<FeaturePtr>());
/// \param theMsg a message with a container of objects
void onFeatureRedisplayMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg);
+ /// Process clearing of presentation
+ /// \param theMsg an event message
void onFeatureEmptyPresentationMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg);
+
/// Displaus object and fit all viewer if the object is first (update viewer will not be called)
/// Asks the module whether the object can be displayed
/// \param theObj an object
