-->
<source>
+ <namevalue id="name"
+ label="Name"
+ placeholder="Please input the group name">
+ </namevalue>
<multi_selector id="group_list"
tooltip="Select a set of objects"
type_choice="Vertices Edges Faces Solids"
<feature id="Group"
title="Group"
tooltip="Create named collection of geometry entities"
- icon="icons/Collection/shape_group.png">
+ icon="icons/Collection/shape_group.png"
+ apply_continue="true">
<source path="group_widget.xml"/>
</feature>
<feature id="Field"
title="Field"
- tooltip="Create create fields for selected shapes"
+ tooltip="Create fields for selected shapes"
icon="icons/Collection/field.png">
<field-panel id="selected">
<validator id="GeomValidators_BodyShapes"/>
myInternal = false;
myUseInput = false;
myNestedFeatures = "";
+ myModal = false;
+ myIsApplyContinue = false;
}
Config_FeatureMessage::~Config_FeatureMessage()
return myModal;
}
+bool Config_FeatureMessage::isApplyContinue() const
+{
+ return myIsApplyContinue;
+}
+
+
void Config_FeatureMessage::setUseInput(bool isUseInput)
{
myUseInput = isUseInput;
{
myIsAutoPreview = isAutoPreview;
}
+
+void Config_FeatureMessage::setApplyContinue(bool isModal)
+{
+ myIsApplyContinue = isModal;
+}
\ No newline at end of file
bool myInternal; ///<Internal feature without GUI representation
bool myModal; ///<True if the feature has to be represented by modal dialog box
bool myIsAutoPreview; ///< Preview computation is performed automatically
+ bool myIsApplyContinue; ///<True if the feature can have Apply/Continue button in its property panel
std::string myNestedFeatures; ///<Space separated list of child features
std::string myActionsWhenNested; ///<Space separated list of actions
CONFIG_EXPORT bool isInternal() const;
/// If true - the feature will be represented by modal dialog box GUI
CONFIG_EXPORT bool isModal() const;
+ /// If true - the feature can have Apply/Continue button in its property panel
+ CONFIG_EXPORT bool isApplyContinue() const;
+
+
/// If true - preview of the feature is done by any modification of the feature attributes
CONFIG_EXPORT bool isAutoPreview() const;
CONFIG_EXPORT void setAutoPreview(bool isAutoPreview);
///Set modality state; If true - the feature will be represented by modal dialog box GUI
CONFIG_EXPORT void setModal(bool isModal);
+ ///Set Apply/Continue state; If true - the feature can have Apply/Continue button in its property panel
+ CONFIG_EXPORT void setApplyContinue(bool isModal);
};
#endif // CONFIG_MESSAGE_H
outFeatureMessage->setModal(getBooleanAttribute(theFeatureNode, FEATURE_MODAL, false));
bool isAutoPreview = getBooleanAttribute(theFeatureNode, FEATURE_AUTO_PREVIEW, true);
outFeatureMessage->setAutoPreview(isAutoPreview);
+ outFeatureMessage->setApplyContinue(
+ getBooleanAttribute(theFeatureNode, FEATURE_APPLY_CONTINUE, false));
bool isInternal = getBooleanAttribute(theFeatureNode, ATTR_INTERNAL, false);
outFeatureMessage->setInternal(isInternal);
const static char* WDG_INTEGERVALUE = "integervalue";
const static char* WDG_BOOLVALUE = "boolvalue";
const static char* WDG_STRINGVALUE = "stringvalue";
+const static char* WDG_NAMEVALUE = "namevalue";
const static char* WDG_MULTISELECTOR = "multi_selector";
const static char* WDG_SHAPE_SELECTOR = "shape_selector";
const static char* WDG_FEATURE_SELECTOR = "feature_selector";
const static char* FEATURE_WHEN_NESTED_ABORT = "abort";
const static char* FEATURE_DOC = WORKBENCH_DOC;
const static char* FEATURE_MODAL = "modal";
+const static char* FEATURE_APPLY_CONTINUE = "apply_continue";
const static char* FEATURE_AUTO_PREVIEW = "auto_preview";
// NODE_VALIDATOR properties
const static char* _PARAMETERS = "parameters";
return isAtLeastOne;
}
+GeomAPI_Shape::ShapeType GeomAPI_Shape::typeOfCompoundShapes() const
+{
+ const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
+ if (aShape.IsNull() || aShape.ShapeType() != TopAbs_COMPOUND)
+ return SHAPE;
+ int aType = -1;
+ for(TopoDS_Iterator aSubs(aShape); aSubs.More(); aSubs.Next()) {
+ if (!aSubs.Value().IsNull()) {
+ if (aType == -1)
+ aType = aSubs.Value().ShapeType();
+ else if (aSubs.Value().ShapeType() != aType)
+ return SHAPE;
+ }
+ }
+ return (GeomAPI_Shape::ShapeType) aType;
+}
+
// adds the nopt-compound elements recursively to the list
static void addSimpleToList(const TopoDS_Shape& theShape, NCollection_List<TopoDS_Shape>& theList)
{
GEOMAPI_EXPORT
bool isIntersect(const std::shared_ptr<GeomAPI_Shape> theShape) const;
- // Translates the shape along the direction for the given offset
+ /// Translates the shape along the direction for the given offset
GEOMAPI_EXPORT
void translate(const std::shared_ptr<GeomAPI_Dir> theDir, const double theOffset);
+
+ /// Returns type of shapes in the compound.
+ // If shapes are of different type then it will return SHAPE type
+ GEOMAPI_EXPORT ShapeType typeOfCompoundShapes() const;
};
//! Pointer on list of shapes
ModuleBase_ModelDialogWidget.h
ModuleBase_ActionParameter.h
ModuleBase_ActionIntParameter.h
+ ModuleBase_ChoiceCtrl.h
+ ModuleBase_WidgetNameEdit.h
)
SET(PROJECT_MOC_HEADERS
ModuleBase_WidgetSwitch.h
ModuleBase_WidgetToolbox.h
ModuleBase_WidgetValidated.h
+ ModuleBase_ChoiceCtrl.h
+ ModuleBase_WidgetNameEdit.h
)
SET(PROJECT_SOURCES
ModuleBase_IconFactory.cpp
ModuleBase_SelectionValidator.cpp
ModuleBase_Dialog.cpp
+ ModuleBase_ChoiceCtrl.cpp
+ ModuleBase_WidgetNameEdit.cpp
)
SET(PROJECT_LIBRARIES
--- /dev/null
+// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or
+// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+//
+
+#include "ModuleBase_ChoiceCtrl.h"
+#include "ModuleBase_Tools.h"
+#include "ModuleBase_IconFactory.h"
+
+#include <QLayout>
+#include <QLabel>
+#include <QComboBox>
+#include <QGroupBox>
+#include <QButtonGroup>
+#include <QRadioButton>
+#include <QToolButton>
+
+ModuleBase_ChoiceCtrl::ModuleBase_ChoiceCtrl(QWidget* theParent,
+ const QStringList& theChoiceList,
+ const QStringList& theIconsList,
+ ControlType theType,
+ Qt::Orientation theButtonsDir)
+ : QWidget(theParent), myType(theType)
+{
+ QHBoxLayout* aLayout = new QHBoxLayout(this);
+ ModuleBase_Tools::adjustMargins(aLayout);
+
+ switch (myType) {
+ case RadioButtons:
+ {
+ myButtons = new QButtonGroup(this);
+ myGroupBox = new QGroupBox("", this);
+ aLayout->addWidget(myGroupBox);
+
+ QLayout* aBtnLayout = 0;
+ switch (theButtonsDir) {
+ case Qt::Horizontal:
+ aBtnLayout = new QHBoxLayout(myGroupBox);
+ break;
+ case Qt::Vertical:
+ aBtnLayout = new QVBoxLayout(myGroupBox);
+ break;
+ }
+ ModuleBase_Tools::adjustMargins(aBtnLayout);
+
+ if (theIconsList.length() == theChoiceList.length()) {
+ int aId = 0;
+ foreach(QString aBtnTxt, theChoiceList) {
+ QToolButton* aBtn = new QToolButton(myGroupBox);
+ aBtn->setFocusPolicy(Qt::StrongFocus);
+ aBtn->setCheckable(true);
+ aBtn->setToolTip(aBtnTxt);
+
+ QPixmap aIcon = ModuleBase_IconFactory::loadPixmap(theIconsList.at(aId));
+ aBtn->setIcon(aIcon);
+ aBtn->setIconSize(aIcon.size());
+
+ aBtnLayout->addWidget(aBtn);
+ myButtons->addButton(aBtn, aId++);
+ }
+ } else {
+ int aId = 0;
+ foreach(QString aBtnTxt, theChoiceList) {
+ QRadioButton* aBtn = new QRadioButton(aBtnTxt, myGroupBox);
+ aBtnLayout->addWidget(aBtn);
+ myButtons->addButton(aBtn, aId++);
+ }
+ }
+ connect(myButtons, SIGNAL(buttonClicked(int)), this, SIGNAL(valueChanged(int)));
+ }
+ break;
+ case ComboBox:
+ myLabel = new QLabel("", this);
+ aLayout->addWidget(myLabel);
+
+ //std::string aToolstr = theData->widgetTooltip();
+ //if (!aToolstr.empty()) {
+ // myLabel->setToolTip(QString::fromStdString(aToolstr));
+ //}
+
+ myCombo = new QComboBox(this);
+ aLayout->addWidget(myCombo, 1);
+
+ myCombo->addItems(theChoiceList);
+ connect(myCombo, SIGNAL(currentIndexChanged(int)), this, SIGNAL(valueChanged(int)));
+ break;
+ }
+}
+
+void ModuleBase_ChoiceCtrl::setLabel(const QString& theText)
+{
+ switch (myType) {
+ case RadioButtons:
+ myGroupBox->setTitle(theText);
+ break;
+ case ComboBox:
+ myLabel->setText(theText);
+ break;
+ }
+}
+
+void ModuleBase_ChoiceCtrl::setLabelIcon(const QString& theIcon)
+{
+ if (myType == ComboBox)
+ myLabel->setPixmap(ModuleBase_IconFactory::loadPixmap(theIcon));
+}
+
+void ModuleBase_ChoiceCtrl::setValue(int theVal)
+{
+ switch (myType) {
+ case RadioButtons:
+ myButtons->button(theVal)->setChecked(true);
+ break;
+ case ComboBox:
+ myCombo->setCurrentIndex(theVal);
+ break;
+ }
+}
+
+void ModuleBase_ChoiceCtrl::setTooltip(QString theTip)
+{
+ if (myType == ComboBox)
+ myLabel->setToolTip(theTip);
+}
+
+int ModuleBase_ChoiceCtrl::value() const
+{
+ switch (myType) {
+ case RadioButtons:
+ return myButtons->checkedId();
+ case ComboBox:
+ return myCombo->currentIndex();
+ }
+ return -1;
+}
+
+bool ModuleBase_ChoiceCtrl::focusTo()
+{
+ if (myType == ComboBox)
+ ModuleBase_Tools::setFocus(myCombo, "ModuleBase_WidgetChoice::focusTo()");
+ else
+ return false;
+ return true;
+}
+
+QList<QWidget*> ModuleBase_ChoiceCtrl::getControls() const
+{
+ QList<QWidget*> aControls;
+ if (myType == ComboBox)
+ aControls.append(myCombo);
+ return aControls;
+}
+
+void ModuleBase_ChoiceCtrl::setChoiceList(const QStringList& theChoiceList)
+{
+ if (myType == ComboBox) {
+ myCombo->clear();
+ myCombo->addItems(theChoiceList);
+ }
+}
+
+QString ModuleBase_ChoiceCtrl::textValue() const
+{
+ switch (myType) {
+ case RadioButtons:
+ return myButtons->checkedButton()->toolTip();
+ case ComboBox:
+ return myCombo->currentText();
+ }
+ return "";
+}
--- /dev/null
+// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or
+// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+//
+
+#ifndef ModuleBase_ChoiceCtrl_H
+#define ModuleBase_ChoiceCtrl_H
+
+#include "ModuleBase.h"
+
+#include <QWidget>
+#include <QStringList>
+#include <QList>
+
+class QLabel;
+class QComboBox;
+class QGroupBox;
+class QButtonGroup;
+
+/**
+* \ingroup GUI
+* A Choice control. It provides a choice in several strings.
+* It can be represented by several radiobuttons or by combo box.
+* Radio buttons can be represented as by radiou buttons with text
+* or by icons in toggle buttons.
+*/
+class MODULEBASE_EXPORT ModuleBase_ChoiceCtrl: public QWidget
+{
+Q_OBJECT
+public:
+ enum ControlType {
+ RadioButtons,
+ ComboBox
+ };
+
+ /**
+ * Constructor
+ * \param theParent a parent widget
+ * \param theChoiceList a list of choice strings
+ * \param theIconsList a list of icon names for radiou buttons
+ * \param theType a type of choice representation
+ * \param theButtonsDir direction of radio buttons placement
+ */
+ ModuleBase_ChoiceCtrl(QWidget* theParent,
+ const QStringList& theChoiceList,
+ const QStringList& theIconsList,
+ ControlType theType = RadioButtons,
+ Qt::Orientation theButtonsDir = Qt::Horizontal);
+
+ /// Set label for the controls.
+ /// It is a label for combo box and title for group of radio buttons.
+ /// \param theText a text of the label
+ void setLabel(const QString& theText);
+
+ /// Set Icon for the label. Used only for combo box.
+ /// \param theIcon a name of icon
+ void setLabelIcon(const QString& theIcon);
+
+ /// Set value: Id of button or item of combo box.
+ /// \param theVal a value (from 0 to number of items)
+ void setValue(int theVal);
+
+ /// Set tool tip for label. Used only for combo box.
+ void setTooltip(QString theTip);
+
+ /// Returns currently selected value
+ int value() const;
+
+ /// Returns text of currently selected value
+ QString textValue() const;
+
+ /// Transfer focus on itself
+ bool focusTo();
+
+ /// Returns controls for activation
+ QList<QWidget*> getControls() const;
+
+ /// Set list of choice
+ /// \param theChoiceList a string list of items
+ void setChoiceList(const QStringList& theChoiceList);
+
+signals:
+ /// A signal raised on change of current value
+ void valueChanged(int theVal);
+
+private:
+ /// Control type
+ ControlType myType;
+
+ /// A label for cmbo box
+ QLabel* myLabel;
+
+ /// A combo box represerntation of control
+ QComboBox* myCombo;
+
+ /// A group box for radio buttons
+ QGroupBox* myGroupBox;
+
+ /// A group of buttons
+ QButtonGroup* myButtons;
+};
+
+#endif
\ No newline at end of file
/// \return a model widget or NULL
static ModuleBase_ModelWidget* findModelWidget(ModuleBase_IPropertyPanel* theProp,
QWidget* theWidget);
+
+ /// Returns True if the widget uses feature attribute.
+ /// If not then it means that the widget do not need attribute at all.
+ virtual bool usesAttribute() const { return true; }
+
signals:
/// The signal about widget values are to be changed
void beforeValuesChanged();
#include "ModuleBase_WidgetChoice.h"
#include "ModuleBase_Tools.h"
#include "ModuleBase_IconFactory.h"
+#include "ModuleBase_ChoiceCtrl.h"
#include <ModelAPI_AttributeInteger.h>
#include <ModelAPI_AttributeStringArray.h>
ModuleBase_WidgetChoice::ModuleBase_WidgetChoice(QWidget* theParent,
const Config_WidgetAPI* theData)
-: ModuleBase_ModelWidget(theParent, theData), myCombo(0), myButtons(0)
+: ModuleBase_ModelWidget(theParent, theData)//, myCombo(0), myButtons(0)
{
- QHBoxLayout* aLayout = new QHBoxLayout(this);
- ModuleBase_Tools::adjustMargins(aLayout);
-
QString aLabelText = translate(theData->widgetLabel());
QString aLabelIcon = QString::fromStdString(theData->widgetIcon());
std::string aTypes = theData->getProperty("string_list");
bool aHasDefaultValue;
int aDefaultVal = QString::fromStdString(getDefaultValue()).toInt(&aHasDefaultValue);
+
// Widget type can be combobox or radiobuttons
std::string aWgtType = theData->getProperty("widget_type");
- if ((aWgtType.length() > 0) && (aWgtType == "radiobuttons")) {
- myButtons = new QButtonGroup(this);
- QGroupBox* aGroupBox = new QGroupBox(aLabelText, this);
- aLayout->addWidget(aGroupBox);
-
-
- QLayout* aBtnLayout = 0;
- std::string aWgtDir = theData->getProperty("buttons_dir");
- if (aWgtDir == "horizontal")
- aBtnLayout = new QHBoxLayout(aGroupBox);
- else
- aBtnLayout = new QVBoxLayout(aGroupBox);
- ModuleBase_Tools::adjustMargins(aBtnLayout);
-
- std::string aIcons = theData->getProperty("icons_list");
- QStringList aIconList = QString(aIcons.c_str()).split(' ');
- if (aIconList.length() == aList.length()) {
- int aId = 0;
- foreach(QString aBtnTxt, aList) {
- QToolButton* aBtn = new QToolButton(aGroupBox);
- aBtn->setFocusPolicy(Qt::StrongFocus);
- aBtn->setCheckable(true);
- aBtn->setToolTip(aBtnTxt);
-
- QPixmap aIcon = ModuleBase_IconFactory::loadPixmap(aIconList.at(aId));
- aBtn->setIcon(aIcon);
- aBtn->setIconSize(aIcon.size());
-
- aBtnLayout->addWidget(aBtn);
- myButtons->addButton(aBtn, aId++);
- }
+ std::string aIcons = theData->getProperty("icons_list");
+ QStringList aIconList = QString(aIcons.c_str()).split(' ');
- } else {
- int aId = 0;
- foreach(QString aBtnTxt, aList) {
- QRadioButton* aBtn = new QRadioButton(aBtnTxt, aGroupBox);
- aBtnLayout->addWidget(aBtn);
- myButtons->addButton(aBtn, aId++);
- }
- }
- int aCheckedId = aHasDefaultValue ? aDefaultVal : 0;
- myButtons->button(aDefaultVal)->setChecked(true);
- connect(myButtons, SIGNAL(buttonClicked(int)), this, SLOT(onCurrentIndexChanged(int)));
- } else {
- myLabel = new QLabel(aLabelText, this);
- if (!aLabelIcon.isEmpty())
- myLabel->setPixmap(ModuleBase_IconFactory::loadPixmap(aLabelIcon));
- aLayout->addWidget(myLabel);
-
- std::string aToolstr = theData->widgetTooltip();
- if (!aToolstr.empty()) {
- myLabel->setToolTip(QString::fromStdString(aToolstr));
- }
+ std::string aWgtDir = theData->getProperty("buttons_dir");
- myCombo = new QComboBox(this);
- aLayout->addWidget(myCombo, 1);
+ QHBoxLayout* aLayout = new QHBoxLayout(this);
+ myChoiceCtrl = new ModuleBase_ChoiceCtrl(this, aList, aIconList,
+ (aWgtType == "radiobuttons")? ModuleBase_ChoiceCtrl::RadioButtons : ModuleBase_ChoiceCtrl::ComboBox,
+ (aWgtDir == "horizontal")? Qt::Horizontal : Qt::Vertical);
+ myChoiceCtrl->setLabel(aLabelText);
- myCombo->addItems(aList);
+ if (!aLabelIcon.isEmpty())
+ myChoiceCtrl->setLabelIcon(aLabelIcon);
- if (aHasDefaultValue && aDefaultVal < aList.size())
- myCombo->setCurrentIndex(aDefaultVal);
+ connect(myChoiceCtrl, SIGNAL(valueChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
- connect(myCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
- }
+ int aCheckedId = aHasDefaultValue ? aDefaultVal : 0;
+ myChoiceCtrl->setValue(aCheckedId);
+ aLayout->addWidget(myChoiceCtrl);
}
ModuleBase_WidgetChoice::~ModuleBase_WidgetChoice()
DataPtr aData = myFeature->data();
std::shared_ptr<ModelAPI_AttributeInteger> aIntAttr = aData->integer(attributeID());
- if (myCombo)
- aIntAttr->setValue(myCombo->currentIndex());
- else
- aIntAttr->setValue(myButtons->checkedId());
+ aIntAttr->setValue(myChoiceCtrl->value());
updateObject(myFeature);
return true;
}
std::shared_ptr<ModelAPI_AttributeInteger> aIntAttr = aData->integer(attributeID());
if (aIntAttr->value() != -1) {
- if (myCombo) {
- bool isBlocked = myCombo->blockSignals(true);
- if (myCombo->count() == 0 && !myStringListAttribute.empty()) {
- AttributeStringArrayPtr aStrAttr = aData->stringArray(myStringListAttribute);
- if (aStrAttr) {
- for (int i = 0; i < aStrAttr->size(); i++) {
- myCombo->insertItem(i, aStrAttr->value(i).c_str());
- }
+ bool isBlocked = myChoiceCtrl->blockSignals(true);
+ if (!myStringListAttribute.empty()) {
+ AttributeStringArrayPtr aStrAttr = aData->stringArray(myStringListAttribute);
+ QStringList aChoiceList;
+ if (aStrAttr) {
+ for (int i = 0; i < aStrAttr->size(); i++) {
+ aChoiceList << aStrAttr->value(i).c_str();
}
+ myChoiceCtrl->setChoiceList(aChoiceList);
}
- myCombo->setCurrentIndex(aIntAttr->value());
- myCombo->blockSignals(isBlocked);
- } else {
- bool isBlocked = myButtons->blockSignals(true);
- if (aIntAttr->isInitialized())
- myButtons->button(aIntAttr->value())->setChecked(true);
- else {
- bool aHasDefaultValue;
- int aDefaultVal = QString::fromStdString(getDefaultValue()).toInt(&aHasDefaultValue);
- myButtons->button(aHasDefaultValue ? aDefaultVal : 0)->setChecked(true);
- }
- myButtons->blockSignals(isBlocked);
- emit itemSelected(this, aIntAttr->value());
}
+ if (aIntAttr->isInitialized())
+ myChoiceCtrl->setValue(aIntAttr->value());
+ else {
+ bool aHasDefaultValue;
+ int aDefaultVal = QString::fromStdString(getDefaultValue()).toInt(&aHasDefaultValue);
+ myChoiceCtrl->setValue(aHasDefaultValue ? aDefaultVal : 0);
+ }
+ myChoiceCtrl->blockSignals(isBlocked);
+ emit itemSelected(this, aIntAttr->value());
}
return true;
}
bool ModuleBase_WidgetChoice::focusTo()
{
- if (myCombo)
- ModuleBase_Tools::setFocus(myCombo, "ModuleBase_WidgetChoice::focusTo()");
- else
- return false;
- return true;
+ return myChoiceCtrl->focusTo();
}
QList<QWidget*> ModuleBase_WidgetChoice::getControls() const
{
- QList<QWidget*> aControls;
- if (myCombo)
- aControls.append(myCombo);
- //else {
- // //foreach(QAbstractButton* aBtn, myButtons->buttons())
- // //if (myButtons->checkedId() != -1)
- // // aControls.append(myButtons->button(myButtons->checkedId()));
- //}
- return aControls;
+ return myChoiceCtrl->getControls();
}
QString ModuleBase_WidgetChoice::getPropertyPanelTitle(int theIndex)
#include "ModuleBase_ModelWidget.h"
class QWidget;
-class QLabel;
-class QComboBox;
-class QButtonGroup;
+class ModuleBase_ChoiceCtrl;
/**
* \ingroup GUI
private:
/// The label
- QLabel* myLabel;
+ //QLabel* myLabel;
/// The control
- QComboBox* myCombo;
- QButtonGroup* myButtons;
+ //QComboBox* myCombo;
+ //QButtonGroup* myButtons;
+ ModuleBase_ChoiceCtrl* myChoiceCtrl;
// XML definition of titles
QStringList myButtonTitles;
#include <ModuleBase_IModule.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_WidgetLineEdit.h>
+#include <ModuleBase_WidgetNameEdit.h>
#include <ModuleBase_WidgetMultiSelector.h>
#include <ModuleBase_WidgetConcealedObjects.h>
#include <ModuleBase_WidgetLabel.h>
} else if (theType == WDG_STRINGVALUE) {
std::string aPlaceHolder = myWidgetApi->getProperty( WDG_PLACE_HOLDER );
result = new ModuleBase_WidgetLineEdit( theParent, myWidgetApi, aPlaceHolder );
+ } else if (theType == WDG_NAMEVALUE) {
+ std::string aPlaceHolder = myWidgetApi->getProperty( WDG_PLACE_HOLDER );
+ result = new ModuleBase_WidgetNameEdit( theParent, myWidgetApi, aPlaceHolder );
} else if (theType == WDG_EXPR_EDITOR) {
std::string aPlaceHolder = myWidgetApi->getProperty( WDG_PLACE_HOLDER );
result = new ModuleBase_WidgetExprEditor( theParent, myWidgetApi, aPlaceHolder );
/// Redefinition of virtual method
virtual bool restoreValueCustom();
-private:
/// A line edit control
QLineEdit* myLineEdit;
};
#include <ModuleBase_IModule.h>
#include <ModuleBase_ISelection.h>
#include <ModuleBase_ISelectionActivate.h>
+#include <ModuleBase_IPropertyPanel.h>
#include <ModuleBase_IViewer.h>
#include <ModuleBase_IWorkshop.h>
#include <ModuleBase_ListView.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_ViewerPrs.h>
#include <ModuleBase_WidgetShapeSelector.h>
+#include <ModuleBase_ChoiceCtrl.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Object.h>
}
#endif
+
+QStringList getIconsList(const QStringList& theNames)
+{
+ QStringList aIcons;
+ foreach (QString aName, theNames) {
+ QString aUName = aName.toUpper();
+ if ((aUName == "VERTICES") || (aUName == "VERTEX"))
+ aIcons << ":pictures/vertex32.png";
+ else if ((aUName == "EDGES") || (aUName == "EDGE"))
+ aIcons << ":pictures/edge32.png";
+ else if ((aUName == "FACES") || (aUName == "FACE"))
+ aIcons << ":pictures/face32.png";
+ else if ((aUName == "SOLIDS") || (aUName == "SOLID"))
+ aIcons << ":pictures/solid32.png";
+ }
+ return aIcons;
+}
+
+
+
ModuleBase_WidgetMultiSelector::ModuleBase_WidgetMultiSelector(QWidget* theParent,
ModuleBase_IWorkshop* theWorkshop,
const Config_WidgetAPI* theData)
: ModuleBase_WidgetSelector(theParent, theWorkshop, theData),
myIsSetSelectionBlocked(false), myCurrentHistoryIndex(-1)
{
+ std::string aPropertyTypes = theData->getProperty("type_choice");
+ QString aTypesStr = aPropertyTypes.c_str();
+ myShapeTypes = aTypesStr.split(' ', QString::SkipEmptyParts);
+ myIsUseChoice = theData->getBooleanAttribute("use_choice", false);
+
QGridLayout* aMainLay = new QGridLayout(this);
ModuleBase_Tools::adjustMargins(aMainLay);
- QLabel* aTypeLabel = new QLabel(tr("Type"), this);
- aMainLay->addWidget(aTypeLabel, 0, 0);
+ QStringList aIconsList = getIconsList(myShapeTypes);
+ myTypeCtrl = new ModuleBase_ChoiceCtrl(this, myShapeTypes, aIconsList);
+ myTypeCtrl->setLabel(tr("Type"));
+ myTypeCtrl->setValue(0);
+ aMainLay->addWidget(myTypeCtrl, 0, 0, 1, 2);
- myTypeCombo = new QComboBox(this);
// There is no sense to parameterize list of types while we can not parameterize selection mode
-
- std::string aPropertyTypes = theData->getProperty("type_choice");
- QString aTypesStr = aPropertyTypes.c_str();
- QStringList aShapeTypes = aTypesStr.split(' ', QString::SkipEmptyParts);
-
- myIsUseChoice = theData->getBooleanAttribute("use_choice", false);
-
- if (!aShapeTypes.empty())
- myTypeCombo->addItems(aShapeTypes);
- aMainLay->addWidget(myTypeCombo, 0, 1);
// if the xml definition contains one type, the controls to select a type should not be shown
- if (aShapeTypes.size() <= 1 || !myIsUseChoice) {
- aTypeLabel->setVisible(false);
- myTypeCombo->setVisible(false);
+ if (myShapeTypes.size() <= 1 || !myIsUseChoice) {
+ myTypeCtrl->setVisible(false);
}
QString aLabelText = translate(theData->getProperty("label"));
aMainLay->addWidget(aListLabel, 1, 0);
// if the xml definition contains one type, an information label
// should be shown near to the latest
- if (aShapeTypes.size() <= 1) {
+ if (myShapeTypes.size() <= 1) {
QString aLabelIcon = QString::fromStdString(theData->widgetIcon());
if (!aLabelIcon.isEmpty()) {
QLabel* aSelectedLabel = new QLabel("", this);
//aMainLay->addWidget(new QLabel(this)); //FIXME(sbh)???
//aMainLay->setRowMinimumHeight(3, 20);
//this->setLayout(aMainLay);
- connect(myTypeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onSelectionTypeChanged()));
+ connect(myTypeCtrl, SIGNAL(valueChanged(int)), this, SLOT(onSelectionTypeChanged()));
myIsNeutralPointClear = theData->getBooleanAttribute("clear_in_neutral_point", true);
}
std::string aType = anAttribute->attributeType();
if (aType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
- aSelectionListAttr->setSelectionType(myTypeCombo->currentText().toStdString());
+ aSelectionListAttr->setSelectionType(myTypeCtrl->textValue().toStdString());
}
return true;
}
QList<QWidget*> ModuleBase_WidgetMultiSelector::getControls() const
{
QList<QWidget*> result;
- //result << myTypeCombo;
result << myListView->getControl();
return result;
}
std::string aType = anAttribute->attributeType();
if (aType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
- aSelectionListAttr->setSelectionType(myTypeCombo->currentText().toStdString());
+ aSelectionListAttr->setSelectionType(myTypeCtrl->textValue().toStdString());
}
// clear attribute values
true); /// hope that something is redisplayed by object updated
// clear history should follow after set selected to do not increase history by setSelected
clearSelectedHistory();
+
+ if (myWorkshop->propertyPanel()->activeWidget() != this)
+ myWorkshop->propertyPanel()->activateWidget(this);
}
//********************************************************************
{
QIntList aShapeTypes;
- if (myTypeCombo->count() > 1 && myIsUseChoice) {
- aShapeTypes.append(ModuleBase_Tools::shapeType(myTypeCombo->currentText()));
+ if (myShapeTypes.length() > 1 && myIsUseChoice) {
+ aShapeTypes.append(ModuleBase_Tools::shapeType(myTypeCtrl->textValue()));
}
else {
- for (int i = 0, aCount = myTypeCombo->count(); i < aCount; i++)
- aShapeTypes.append(ModuleBase_Tools::shapeType(myTypeCombo->itemText(i)));
+ foreach (QString aType, myShapeTypes) {
+ aShapeTypes.append(ModuleBase_Tools::shapeType(aType));
+ }
}
return aShapeTypes;
}
{
QString aShapeTypeName;
- for (int idx = 0; idx < myTypeCombo->count(); ++idx) {
- aShapeTypeName = myTypeCombo->itemText(idx);
+ int idx = 0;
+ foreach (QString aShapeTypeName, myShapeTypes) {
int aRefType = ModuleBase_Tools::shapeType(aShapeTypeName);
- if(aRefType == theShapeType && idx != myTypeCombo->currentIndex()) {
+ if(aRefType == theShapeType && idx != myTypeCtrl->value()) {
updateSelectionModesAndFilters(false);
- bool isBlocked = myTypeCombo->blockSignals(true);
- myTypeCombo->setCurrentIndex(idx);
- myTypeCombo->blockSignals(isBlocked);
+ bool isBlocked = myTypeCtrl->blockSignals(true);
+ myTypeCtrl->setValue(idx);
+ myTypeCtrl->blockSignals(isBlocked);
updateSelectionModesAndFilters(true);
break;
}
+ idx++;
}
}
#include <QMap>
class QWidget;
-class QComboBox;
+//class QComboBox;
class ModuleBase_ListView;
class ModuleBase_IWorkshop;
+class ModuleBase_ChoiceCtrl;
/**
* \ingroup GUI
protected:
ModuleBase_ListView* myListView; ///< List control
- QComboBox* myTypeCombo; ///< Combobox of types
- bool myIsUseChoice; /// A flag to store use_choice parameter state
+
+ bool myIsUseChoice; ///< A flag to store use_choice parameter state
+
+ QStringList myShapeTypes; ///< List of Shape types defined in XML
+
+ /// Control for types
+ ModuleBase_ChoiceCtrl* myTypeCtrl;
/// A flag to clear selection by click in empty place in the viewer
bool myIsNeutralPointClear;
/// A container of selected objects
QList<QList<std::shared_ptr<ModuleBase_ViewerPrs> > > mySelectedHistoryValues;
+
/// Position in a container of selected values
int myCurrentHistoryIndex;
};
--- /dev/null
+// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or
+// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+//
+
+#include "ModuleBase_WidgetNameEdit.h"
+
+#include <ModelAPI_Result.h>
+
+#include <QLineEdit>
+
+bool ModuleBase_WidgetNameEdit::storeValueCustom()
+{
+ if(!myFeature)
+ return false;
+
+ QString aValue = myLineEdit->text();
+ std::string aName = aValue.toStdString();
+ myFeature->data()->setName(aName);
+ ResultPtr aRes = myFeature->firstResult();
+ if (aRes.get())
+ aRes->data()->setName(aName);
+ updateObject(myFeature);
+ return true;
+}
+
+bool ModuleBase_WidgetNameEdit::restoreValueCustom()
+{
+ if(!myFeature)
+ return false;
+
+ bool isBlocked = myLineEdit->blockSignals(true);
+ myLineEdit->setText(QString::fromStdString(myFeature->data()->name()));
+ myLineEdit->blockSignals(isBlocked);
+
+ return true;
+}
\ No newline at end of file
--- /dev/null
+// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or
+// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+//
+
+#ifndef MODULEBASE_WIDGETNAMEEDIT_H_
+#define MODULEBASE_WIDGETNAMEEDIT_H_
+
+#include <ModuleBase.h>
+#include <ModuleBase_WidgetLineEdit.h>
+
+class ModuleBase_WidgetNameEdit : public ModuleBase_WidgetLineEdit
+{
+ Q_OBJECT
+public:
+ ModuleBase_WidgetNameEdit( QWidget* theParent,
+ const Config_WidgetAPI* theData,
+ const std::string& thePlaceHolder )
+ : ModuleBase_WidgetLineEdit(theParent, theData, thePlaceHolder) {}
+
+ /// Returns True if the widget uses feature attribute.
+ /// If not then it means that the widget do not need attribute at all.
+ virtual bool usesAttribute() const { return false; }
+
+protected:
+ /// Saves the internal parameters to the given feature
+ /// \return True in success
+ virtual bool storeValueCustom();
+
+ /// Redefinition of virtual method
+ virtual bool restoreValueCustom();
+};
+
+#endif
\ No newline at end of file
${PROJECT_SOURCE_DIR}/src/FeaturesPlugin
${PROJECT_SOURCE_DIR}/src/PartSetPlugin
${PROJECT_SOURCE_DIR}/src/GeomAPI
+ ${PROJECT_SOURCE_DIR}/src/CollectionPlugin
${CAS_INCLUDE_DIRS}
${SUIT_INCLUDE}
)
#include <Config_FeatureMessage.h>
#include <Events_Loop.h>
+#include <CollectionPlugin_Group.h>
+
QMap<QString, QString> PartSet_IconFactory::myIcons;
PartSet_IconFactory::PartSet_IconFactory():ModuleBase_IconFactory()
if(aShape.get()) {
switch(aShape->shapeType()) {
case GeomAPI_Shape::COMPOUND: {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObj);
+ if (aFeature.get() && aFeature->getKind() == CollectionPlugin_Group::ID()) {
+ switch (aShape->typeOfCompoundShapes()) {
+ case GeomAPI_Shape::VERTEX:
+ return QIcon(":icons/group_vertex.png");
+ case GeomAPI_Shape::EDGE:
+ return QIcon(":icons/group_edge.png");
+ case GeomAPI_Shape::FACE:
+ return QIcon(":icons/group_face.png");
+ case GeomAPI_Shape::SOLID:
+ return QIcon(":icons/group_solid.png");
+ }
+ }
ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResult);
if (aBody.get() && aBody->isConnectedTopology())
return QIcon(":pictures/compoundofsolids.png");
<file>icons/sketch_shape.png</file>
<file>icons/expression.png</file>
<file>icons/paper_roll.png</file>
+
+ <file>icons/group_edge.png</file>
+ <file>icons/group_face.png</file>
+ <file>icons/group_solid.png</file>
+ <file>icons/group_vertex.png</file>
</qresource>
</RCC>
"Apply" /*empty to show error*/, aParent);
}
break;
+ case AcceptPlus: {
+ aResult = ModuleBase_Tools::createAction(QIcon(":pictures/button_ok-plus.png"),
+ "Apply and continue" /*empty to show error*/, aParent);
+ }
+ break;
case Abort:
case AbortAll: {
aResult = ModuleBase_Tools::createAction(QIcon(":pictures/button_cancel.png"), "Cancel",
enum OperationStateActionId {
Abort = 0,
Accept = 1,
- Help = 2,
- AbortAll = 3,
- AcceptAll = 4,
- Preview = 5
+ AcceptPlus = 2,
+ Help = 3,
+ AbortAll = 4,
+ AcceptAll = 5,
+ Preview = 6
};
/// Add a command in the manager.
{
XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
QAction* anAcceptAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
+ QAction* anAcceptPlusAction =
+ anActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptPlus);
if (myAcceptAllToolTip.isEmpty() && myAcceptToolTip.isEmpty())
storeInitialActionValues();
bool anEnabled = theError.isEmpty();
anAcceptAction->setEnabled(anEnabled);
+ anAcceptPlusAction->setEnabled(anEnabled);
anAcceptAction->setToolTip(anEnabled ? myAcceptToolTip : theError);
anAcceptAction->setStatusTip(anEnabled ? myAcceptStatusTip : theError);
// some operations have no property panel, so it is important to check that it is not null
#include <ModuleBase_WidgetFactory.h>
#include <ModuleBase_OperationDescription.h>
#include <ModuleBase_Events.h>
+#include <ModuleBase_IWorkshop.h>
#include <Events_Loop.h>
#include <QVBoxLayout>
#include <QGridLayout>
#include <QWidget>
-#include <QToolButton>
#include <QAction>
#ifdef _DEBUG
QStringList aBtnNames;
aBtnNames << QString(PROP_PANEL_HELP)
<< QString(PROP_PANEL_OK)
+ << QString(PROP_PANEL_OK_PLUS)
<< QString(PROP_PANEL_CANCEL);
foreach(QString eachBtnName, aBtnNames) {
QToolButton* aBtn = new QToolButton(aFrm);
/// Apply button should be update if the feature was modified by the panel
myOperationMgr->onValidateOperation();
}
+ std::shared_ptr<Config_FeatureMessage> aFeatureInfo =
+ myOperationMgr->workshop()->featureInfo(theFeature->getKind().c_str());
+ findButton(PROP_PANEL_OK_PLUS)->setVisible(aFeatureInfo->isApplyContinue());
}
void XGUI_PropertyPanel::activateNextWidget(ModuleBase_ModelWidget* theWidget)
findDirectChildren(this, aChildren, true);
int aChildrenCount = aChildren.count();
int aFocusWidgetIndex = aChildren.indexOf(aFocusWidget);
+ QToolButton* anOkBtn = findButton(PROP_PANEL_OK);
if (aFocusWidgetIndex >= 0) {
if (theIsNext) {
if (aFocusWidgetIndex == aChildrenCount-1) {
// after the last widget focus should be set to "Apply"
- QToolButton* anOkBtn = findButton(PROP_PANEL_OK);
if (anOkBtn->isEnabled())
aNewFocusWidget = anOkBtn;
else {
}
else {
// before the "Apply" button, the last should accept focus for consistency with "Next"
- QToolButton* anOkBtn = findButton(PROP_PANEL_OK);
if (aFocusWidget == anOkBtn) {
aNewFocusWidget = aChildren[aChildrenCount - 1];
}
void XGUI_PropertyPanel::setupActions(XGUI_ActionsMgr* theMgr)
{
QStringList aButtonNames;
- aButtonNames << PROP_PANEL_OK << PROP_PANEL_CANCEL << PROP_PANEL_HELP << PROP_PANEL_PREVIEW;
+ aButtonNames << PROP_PANEL_OK<< PROP_PANEL_OK_PLUS << PROP_PANEL_CANCEL
+ << PROP_PANEL_HELP << PROP_PANEL_PREVIEW;
QList<XGUI_ActionsMgr::OperationStateActionId> aActionIds;
- aActionIds << XGUI_ActionsMgr::Accept << XGUI_ActionsMgr::Abort << XGUI_ActionsMgr::Help
- << XGUI_ActionsMgr::Preview;
+ aActionIds << XGUI_ActionsMgr::Accept << XGUI_ActionsMgr::AcceptPlus << XGUI_ActionsMgr::Abort
+ << XGUI_ActionsMgr::Help << XGUI_ActionsMgr::Preview;
for (int i = 0; i < aButtonNames.size(); ++i) {
QToolButton* aBtn = findButton(aButtonNames.at(i).toStdString().c_str());
QAction* anAct = theMgr->operationStateAction(aActionIds.at(i));
/// Internal name of Ok button
const static char* PROP_PANEL_OK = "property_panel_ok";
+/// Internal name of Ok button
+const static char* PROP_PANEL_OK_PLUS = "property_panel_ok_plus";
+
/// Internal name of Cancel button
const static char* PROP_PANEL_CANCEL = "property_panel_cancel";
}
}
+//******************************************************
+void XGUI_Workshop::onAcceptPlusActionClicked()
+{
+ QAction* anAction = dynamic_cast<QAction*>(sender());
+ XGUI_OperationMgr* anOperationMgr = operationMgr();
+ if (anOperationMgr) {
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (anOperationMgr->currentOperation());
+ if (aFOperation) {
+ myOperationMgr->commitOperation();
+ module()->launchOperation(aFOperation->id(), false);
+ }
+ }
+}
+
//******************************************************
void XGUI_Workshop::onPreviewActionClicked()
{
FeaturePtr aFeature = aFOperation->feature();
std::string aFeatureKind = aFeature->getKind();
foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
- if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
- std::string anErrorMsg = "The feature '%1' has no attribute '%2' used by widget '%3'.";
- Events_InfoMessage("XGUI_Workshop", anErrorMsg)
- .arg(aFeatureKind).arg(aWidget->attributeID())
- .arg(aWidget->metaObject()->className()).send();
- myPropertyPanel->cleanContent();
- return;
+ if (aWidget->usesAttribute()) {
+ if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
+ std::string anErrorMsg = "The feature '%1' has no attribute '%2' used by widget '%3'.";
+ Events_InfoMessage("XGUI_Workshop", anErrorMsg)
+ .arg(aFeatureKind).arg(aWidget->attributeID())
+ .arg(aWidget->metaObject()->className()).send();
+ myPropertyPanel->cleanContent();
+ return;
+ }
}
}
// for performance purpose, flush should be done after all controls are filled
QAction* aOkAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
connect(aOkAct, SIGNAL(triggered()), this, SLOT(onAcceptActionClicked()));
+ QAction* aOkContAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptPlus);
+ connect(aOkContAct, SIGNAL(triggered()), this, SLOT(onAcceptPlusActionClicked()));
+
QAction* aCancelAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Abort);
connect(aCancelAct, SIGNAL(triggered()), myOperationMgr, SLOT(onAbortOperation()));
/// the operation can be committed and do it if it returns true.
void onAcceptActionClicked();
+ /// Called by OkPlus button clicked in the property panel. Asks the error manager whether
+ /// the operation can be committed and do it if it returns true.
+ void onAcceptPlusActionClicked();
+
/// Called by Preview button clicked in the property panel. Sends signal to model to
/// compute preview.
void onPreviewActionClicked();
<file>pictures/button_help.png</file>
<file>pictures/button_ok.png</file>
<file>pictures/button_ok_error.png</file>
+ <file>pictures/button_ok-plus.png</file>
<file>pictures/button_plus.png</file>
<file>pictures/assembly.png</file>
<file>pictures/eyeopen.png</file>
<file>pictures/transparency.png</file>
+ <file>pictures/solid32.png</file>
+ <file>pictures/face32.png</file>
+ <file>pictures/edge32.png</file>
+ <file>pictures/vertex32.png</file>
<file>pictures/features_folder.png</file>
<file>pictures/create_folder.png</file>
<file>pictures/insert_folder_after.png</file>
