src/ModuleBase/ModuleBase_Tools.h

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        ModuleBase_Tools.h
   4 // Created:     11 July 2014
   5 // Author:      Vitaly Smetannikov
   6
   7 #ifndef ModuleBase_Tools_H
   8 #define ModuleBase_Tools_H
   9
  10 #include "ModuleBase.h"
  11 #include "ModuleBase_Definitions.h"
  12
  13 #include <ModelAPI_Attribute.h>
  14 #include <ModelAPI_Feature.h>
  15
  16 #include <TopAbs_ShapeEnum.hxx>
  17 #include <TopoDS_Shape.hxx>
  18 #include <Prs3d_Drawer.hxx>
  19
  20 #include <Quantity_Color.hxx>
  21
  22 #include <QIcon>
  23 #include <QPixmap>
  24
  25 #include <map>
  26
  27 class Handle_AIS_InteractiveContext;
  28
  29 class QWidget;
  30 class QLayout;
  31 class QDoubleSpinBox;
  32 class QAction;
  33 class ModuleBase_ParamIntSpinBox;
  34 class ModuleBase_ParamSpinBox;
  35 class ModuleBase_IWorkshop;
  36
  37 class GeomAPI_Shape;
  38
  39 namespace ModuleBase_Tools {
  40
  41 /*
  42  * Methods to adjust margins and spacings.
  43  */
  44 MODULEBASE_EXPORT void adjustMargins(QWidget* theWidget);
  45 MODULEBASE_EXPORT void adjustMargins(QLayout* theLayout);
  46
  47 MODULEBASE_EXPORT void zeroMargins(QWidget* theWidget);
  48 MODULEBASE_EXPORT void zeroMargins(QLayout* theLayout);
  49
  50 /*
  51  * Calls the same-named Qt method for the given widget.
  52  * It sets the top-level widget containing this widget to be the active window.
  53  * An active window is a visible top-level window that has the keyboard input focus.
  54  * \param theWidget a widget to be activated
  55  * \param theIndo a debug information
  56  */
  57 MODULEBASE_EXPORT void activateWindow(QWidget* theWidget, const QString& theInfo = QString());
  58
  59 /*
  60  * Calls the same-named Qt method for the given widget.
  61  * Gives the keyboard input focus to this widget (or its focus proxy) if this widget or
  62  * one of its parents is the active window.
  63  * \param theWidget a widget to be activated
  64  * \param theIndo a debug information
  65  */
  66 MODULEBASE_EXPORT void setFocus(QWidget* theWidget, const QString& theInfo = QString());
  67
  68
  69 //! Sets or removes the shadow effect to the widget
  70 //! \param theWidget a widget to be styled
  71 //! \param isSetEffect if true, the shadow effect is set, overwise cleared
  72 //! \return resulting pixmap
  73 MODULEBASE_EXPORT void setShadowEffect(QWidget* theWidget, const bool isSetEffect);
  74
  75 /**
  76  * \ingroup GUI
  77  * Methods to modify a resource pixmap
  78  */
  79
  80 //! Create composite pixmap.
  81 //! Pixmap \a theAdditionalIcon is drawn over pixmap \a dest with coordinates
  82 //! specified relatively to the upper left corner of \a theIcon.
  83
  84 //! \param theAdditionalIcon resource text of the additional pixmap
  85 //! \param theIcon resource text of the background pixmap
  86 //! \return resulting pixmap
  87 MODULEBASE_EXPORT QPixmap composite(const QString& theAdditionalIcon, const QString& theIcon);
  88
  89 //! Generates the pixmap lighter than the resources pixmap.
  90 //! Pixmap \a theIcon is lighted according to the given value.
  91 //! If the lighter value is greater than 100, this functions returns a lighter pixmap.
  92 //! Setting lighter value to 150 returns a color that is 50% brighter. If the factor is less than 100,
  93 //! the return pixmap is darker. If the factor is 0 or negative, the return pixmap is unspecified.
  94
  95 //! \param resource text of the pixmap
  96 //! \param theLighterValue a lighter factor
  97 //! \return resulting pixmap
  98 MODULEBASE_EXPORT QPixmap lighter(const QString& theIcon, const int theLighterValue = 200);
  99
 100 /// Sets programmatically the value to the spin box without emitting any signals(e.g. valueChanged)
 101 /// \param theSpin an X or Y coordinate widget
 102 /// \param theValue a new value
 103 MODULEBASE_EXPORT void setSpinValue(QDoubleSpinBox* theSpin, double theValue);
 104
 105 /// Sets programmatically the value to the spin box without emitting any signals(e.g. valueChanged)
 106 /// \param theSpin an X or Y coordinate widget
 107 /// \param theValue a new value
 108 MODULEBASE_EXPORT void setSpinValue(ModuleBase_ParamSpinBox* theSpin, double theValue);
 109
 110 /// Sets programmatically the value to the spin box without emitting any signals(e.g. valueChanged)
 111 /// \param theSpin an ModuleBase_ParamSpinBox that accepts text
 112 /// \param theText a new value
 113 MODULEBASE_EXPORT void setSpinText(ModuleBase_ParamSpinBox* theSpin, const QString& theText);
 114
 115 /// Sets programmatically the value to the spin box without emitting any signals(e.g. valueChanged)
 116 /// \param theSpin a ModuleBase_ParamIntSpinBox object
 117 /// \param theValue a new value
 118 MODULEBASE_EXPORT void setSpinValue(ModuleBase_ParamIntSpinBox* theSpin, int theValue);
 119
 120 /// Sets programmatically the value to the spin box without emitting any signals(e.g. valueChanged)
 121 /// \param theSpin a SpinBox that accepts text
 122 /// \param theText a new value
 123 MODULEBASE_EXPORT void setSpinText(ModuleBase_ParamIntSpinBox* theSpin, const QString& theText);
 124
 125 /// Creates an action filled with the parameters
 126 /// \param theIcon an action icon
 127 /// \param theText an icon text
 128 /// \param theParent an action object
 129 /// \param theReceiver an object to process action triggered signal
 130 /// \param theMember a slot to process the action triggered signal
 131 /// \param theToolTip an action tool tip information, if empty the text is used
 132 /// \param theStatusTip an action status tip information, if empty the text is used
 133 MODULEBASE_EXPORT QAction* createAction(const QIcon& theIcon, const QString& theText,
 134                                         QObject* theParent, const QObject* theReceiver = 0,
 135                                         const char* theMember = "",
 136                                         const QString& theToolTip = QString(),
 137                                         const QString& theStatusTip = QString());
 138
 139 /// Converts the object to the feature or a result and generate information string
 140 /// \param theObj an object
 141 /// \param isUseAttributesInfo a flag whether the attribute values information is used
 142 /// \return a string
 143 MODULEBASE_EXPORT QString objectInfo(const ObjectPtr& theObj, const bool isUseAttributesInfo = false);
 144
 145 /// Converts the AIS context information in a string information.
 146 /// \param theContext a viewer context
 147 /// \param thePrefix additional information where the method is called
 148 MODULEBASE_EXPORT void selectionInfo(Handle_AIS_InteractiveContext& theContext,
 149                                      const std::string& thePrefix);
 150
 151 /// Converts string value (name of shape type) to shape enum value
 152 /// \param theType - string with shape type name
 153 /// \return TopAbs_ShapeEnum value
 154 MODULEBASE_EXPORT TopAbs_ShapeEnum shapeType(const QString& theType);
 155
 156 /// Checks whether the object is a sub result. It gets the feature of the object,
 157 /// obtains all results of the feature and check if the object is a sub result
 158 /// \return boolean result
 159 MODULEBASE_EXPORT bool isSubResult(ObjectPtr theObject);
 160
 161 /*!
 162 Check types of objects which are in the given list
 163 \param theObjects the list of objects
 164 \param hasResult will be set to true if list contains Result objects
 165 \param hasFeature will be set to true if list contains Feature objects
 166 \param hasParameter will be set to true if list contains Parameter objects
 167 \param hasCompositeOwner will be set to true if list contains Sub-Feature objects
 168 */
 169 MODULEBASE_EXPORT void checkObjects(const QObjectPtrList& theObjects, bool& hasResult,
 170                            bool& hasFeature, bool& hasParameter, bool& hasCompositeOwner);
 171
 172 /*! Sets the default coeffient into the driver calculated accordingly the shape type.
 173 It provides 1.e-4 for a shape withe Edge shape type
 174 \param theShape a shape to define the deviation coeffient,
 175 \param theDrawer a drawer
 176 */
 177 MODULEBASE_EXPORT void setDefaultDeviationCoefficient(const TopoDS_Shape& theShape,
 178                                                       const Handle(Prs3d_Drawer)& theDrawer);
 179
 180 /*! Obtains the color from the property manager and converts it to the OCCT color
 181 \param theSection a property section
 182 \param theName a property item name
 183 \param theDefault a default color value
 184 \return quantity color
 185 */
 186 MODULEBASE_EXPORT Quantity_Color color(const std::string& theSection,
 187                                        const std::string& theName,
 188                                        const std::string& theDefault);
 189
 190
 191 /// Returns the object from the attribute
 192 /// \param theObj an object
 193 MODULEBASE_EXPORT ObjectPtr getObject(const AttributePtr& theAttribute);
 194
 195 /// Returns the object from the attribute
 196 /// \param theObj an object
 197 MODULEBASE_EXPORT TopAbs_ShapeEnum getCompoundSubType(const TopoDS_Shape& theShape);
 198
 199 /// Returns list of parameters accessible in the active part and partset
 200 /// \theParameters a list of parameter names
 201 MODULEBASE_EXPORT void getParameters(QStringList& theParameters);
 202
 203 /// Returns list of parameters accessible in the active part and partset
 204 /// \theParameters a list of parameter names
 205 MODULEBASE_EXPORT std::string findGreedAttribute(ModuleBase_IWorkshop* theWorkshop,
 206                                                  const FeaturePtr& theFeature);
 207
 208 /// Set the object to the attribute depending on the attribute type. If it is a list,
 209 /// the values are appended if they are not in the list yet.
 210 /// \param theAttribute an attribute where the object and shape are set
 211 /// \param theObject an object
 212 /// \param theShape a shape
 213 /// \param theWorkshop to find an attribute for the given shape for attribute reference
 214 /// \param theTemporarily if it is true, do not store and name the added in the data framework
 215 ///        It is useful for attribute selection
 216 MODULEBASE_EXPORT bool hasObject(const AttributePtr& theAttribute, const ObjectPtr& theObject,
 217                                  const std::shared_ptr<GeomAPI_Shape>& theShape,
 218                                  ModuleBase_IWorkshop* theWorkshop,
 219                                  const bool theTemporarily);
 220
 221 /// Set the object to the attribute depending on the attribute type. If it is a list,
 222 /// the values are appended if they are not in the list yet.
 223 /// \param theAttribute an attribute where the object and shape are set
 224 /// \param theObject an object
 225 /// \param theShape a shape
 226 /// \param theWorkshop to find an attribute for the given shape for attribute reference
 227 /// \param theTemporarily if it is true, do not store and name the added in the data framework
 228 /// \param theCheckIfAttributeHasObject if it is true, the check isInList is called
 229 ///        It is useful for attribute selection
 230 MODULEBASE_EXPORT void setObject(const AttributePtr& theAttribute, const ObjectPtr& theObject,
 231                                  const std::shared_ptr<GeomAPI_Shape>& theShape,
 232                                  ModuleBase_IWorkshop* theWorkshop,
 233                                  const bool theTemporarily,
 234                                  const bool theCheckIfAttributeHasObject);
 235
 236 /// Returns the shape of the attribute. If the attribute is AttributeRefAttrPtr, the shape is found
 237 /// using current module of the given workshop.
 238 /// \param theAttribute an attribute where the shape is set
 239 /// \param theWorkshop to find a shape for the given attribute
 240 MODULEBASE_EXPORT std::shared_ptr<GeomAPI_Shape> getShape(const AttributePtr& theAttribute,
 241                                                           ModuleBase_IWorkshop* theWorkshop);
 242
 243 /// Flush updated signal for the object. The viewer update is blocked in the process
 244 /// \param theObject parameter of the signal
 245 MODULEBASE_EXPORT void flushUpdated(ObjectPtr theObject);
 246
 247 /// Sends a message about block/unblock viewer updating
 248 /// \param theValue a boolean value
 249 MODULEBASE_EXPORT void blockUpdateViewer(const bool theValue);
 250
 251 /// Generates a wrapped string to be less than value with '\n' separators
 252 /// \param theValue a boolean value
 253 /// \param theWidget a widget to know the font
 254 /// \param theMaxLineInPixels a maximum line width in pixels
 255 MODULEBASE_EXPORT QString wrapTextByWords(const QString& theValue, QWidget* theWidget,
 256                                              int theMaxLineInPixels = 150);
 257
 258 /*!
 259   Returns a container of referenced feature to the current object in the object document.
 260   \param theObject an object, which will be casted to a feature type
 261   \param theRefFeatures an output container
 262  */
 263 void MODULEBASE_EXPORT refsToFeatureInFeatureDocument(const ObjectPtr& theObject,
 264                                                       std::set<FeaturePtr>& theRefFeatures);
 265
 266
 267 /*!
 268  Returns true if the object if a sub child of the feature. The feature is casted to the
 269  composite one. If it is possible, the sub object check happens. The method is applyed
 270  recursively to the feature subs.
 271  \param theObject a candidate to be a sub object
 272  \param theFeature a candidate to be a composite feature
 273  \return a boolean value
 274  */
 275 bool MODULEBASE_EXPORT isSubOfComposite(const ObjectPtr& theObject, const FeaturePtr& theFeature);
 276
 277
 278 /*!
 279 * Returns true if the result is a sub object of some composite object
 280 * \param theObject a result object
 281 * \returns boolean value
 282 */
 283 bool MODULEBASE_EXPORT isSubOfComposite(const ObjectPtr& theObject);
 284
 285
 286 /*!
 287 * Shows a dialog box about references. Ask whether they should be also removed.
 288 * \param theFeatures a list of features
 289 * \param theReferences a map of all references to the features
 290 * \param theParent a parent widget for the question message box
 291 * \param theReferencesToDelete an out set for references features to be removed
 292 * \return true if in message box answer is Yes
 293 */
 294 bool MODULEBASE_EXPORT askToDelete(const std::set<FeaturePtr> aFeatures,
 295                                    const std::map<FeaturePtr, std::set<FeaturePtr> >& theReferences,
 296                                    QWidget* theParent,
 297                                    std::set<FeaturePtr>& theReferencesToDelete);
 298
 299 /*!
 300 * Converts a list of objects to set of corresponded features. If object is result, it is ingored
 301 * because the feauture only might be removed. But if result is in a parameter group, the feature
 302 * of this parameter is to be removed
 303 * \param theObjects a list of objects
 304 * \param theFeatures an out conteiner of features
 305 */
 306 void MODULEBASE_EXPORT convertToFeatures(const QObjectPtrList& theObjects, std::set<FeaturePtr>& theFeatures);
 307
 308 }
 309
 310 #endif