-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2022 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
#include "XGUI_Tools.h"
#include "XGUI_ViewerProxy.h"
#include "XGUI_WorkshopListener.h"
-#include <XGUI_CustomPrs.h>
#include <XGUI_HistoryMenu.h>
#include <XGUI_QtEvents.h>
#include <XGUI_DataModel.h>
#include <XGUI_InspectionPanel.h>
#include <XGUI_CompressFiles.h>
-#ifndef HAVE_SALOME
+#ifdef HAVE_SALOME
+#include <SUIT_Application.h>
+#include <SUIT_Session.h>
+#else
#include <AppElements_Button.h>
#include <AppElements_Command.h>
#include <AppElements_MainMenu.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_AttributeString.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Events.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_Tools.h>
#include <ModelAPI_ResultField.h>
+#include <ModuleBase_IconFactory.h>
//#include <PartSetPlugin_Part.h>
#include <Events_InfoMessage.h>
#include <Events_LongOp.h>
+#include <ExchangePlugin_ExportPart.h>
+#include <ExchangePlugin_ImportPart.h>
+#include <ExchangePlugin_Import.h>
+#include <ExchangePlugin_ExportFeature.h>
+
#include <GeomAPI_Pnt.h>
+#include <GeomAPI_ShapeExplorer.h>
#include <ModuleBase_IModule.h>
#include <ModuleBase_IViewer.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_WidgetFactory.h>
#include <ModuleBase_OperationFeature.h>
-#include <ModuleBase_OperationAction.h>
#include <ModuleBase_PagedContainer.h>
#include <ModuleBase_WidgetValidated.h>
#include <ModuleBase_ModelWidget.h>
#include <QDesktopWidget>
#include <QProcess>
#include <QDesktopServices>
+#include <QFormLayout>
+#include <QSpinBox>
+#include <QDialogButtonBox>
+#include <sstream>
#include <iterator>
#ifdef TINSPECTOR
-#include <CDF_Session.hxx>
-#include <CDF_Application.hxx>
+#include <TDocStd_Application.hxx>
#include <inspector/TInspector_Communicator.hxx>
#include <inspector/VInspector_CallBack.hxx>
static TInspector_Communicator* MyTCommunicator;
static Handle(VInspector_CallBack) MyVCallBack;
-
#endif
#ifdef _DEBUG
#ifdef WIN32
#include <windows.h>
+#pragma warning(disable : 4456) // for nested foreach
+#pragma warning(disable : 4189) // for declaration of unused variables (MAYBE_UNUSED)
#else
#include <dlfcn.h>
#endif
//#define DEBUG_WITH_MESSAGE_REPORT
QString XGUI_Workshop::MOVE_TO_END_COMMAND = QObject::tr("Move to the end");
+QString XGUI_Workshop::MOVE_TO_END_SPLIT_COMMAND = QObject::tr("Move to the end and split");
//#define DEBUG_DELETE
//#define DEBUG_FEATURE_NAME
static QString MyExtension(".cadbld");
#endif
+static QString MyImportPartFilter(QObject::tr("Part files (*.shaperpart);;All files (*.*)"));
+
//******************************************************
XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
: QObject(),
myModule(NULL),
- mySalomeConnector(theConnector),
+ myObjectBrowser(0),
myPropertyPanel(0),
- myInspectionPanel(0),
myFacesPanel(0),
- myObjectBrowser(0),
- myDisplayer(0)
- //myViewerSelMode(TopAbs_FACE)
+ myDisplayer(0),
+ mySalomeConnector(theConnector),
+ //myViewerSelMode(TopAbs_FACE),
+ myInspectionPanel(0)
{
mySelector = new XGUI_SelectionMgr(this);
myModuleConnector = new XGUI_ModuleConnector(this);
- myOperationMgr = new XGUI_OperationMgr(this, 0);
+ myOperationMgr = new XGUI_OperationMgr(this, myModuleConnector);
ModuleBase_IWorkshop* aWorkshop = moduleConnector();
// Has to be defined first in order to get errors and messages from other components
myEventsListener = new XGUI_WorkshopListener(this);
// Load translations
QStringList aLangs;
aLangs << "*_en.ts"; // load by default eng translations
+
+ /// If version of OCCT is 7.4.0 or more then it means that
+ /// this is version of SALOME older then 9.4.0
+#if OCC_VERSION_HEX >= 0x070400
+ QString aCurrLang = aResMgr->language();
+#else
QString aCurrLang = aResMgr->stringValue("language", "language", "en");
+#endif
+
if(aCurrLang != "en") {
aLangs << "*_" + aCurrLang + ".ts"; // then replace with translated files
}
//connect(myViewerProxy, SIGNAL(selectionChanged()),
// myActionsMgr, SLOT(updateOnViewSelection()));
- myOperationMgr->setWorkshop(aWorkshop);
-
myErrorMgr = new XGUI_ErrorMgr(this, aWorkshop);
connect(myOperationMgr, SIGNAL(operationResumed(ModuleBase_Operation*)),
#ifndef HAVE_SALOME
connect(myMainWindow, SIGNAL(exitKeySequence()), SLOT(onExit()));
- onTrihedronVisibilityChanged(true);
+ myDisplayer->displayTrihedron(true);
#endif
connect(myEventsListener, SIGNAL(errorOccurred(std::shared_ptr<Events_InfoMessage>)),
myErrorDlg, SLOT(addError(std::shared_ptr<Events_InfoMessage>)));
- //Config_PropManager::registerProp("Visualization", "object_default_color", "Object color",
- // Config_Prop::Color, "225,225,225");
-
- Config_PropManager::registerProp("Visualization", "result_body_color", "Result color",
- Config_Prop::Color, ModelAPI_ResultBody::DEFAULT_COLOR());
- Config_PropManager::registerProp("Visualization", "result_group_color", "Group color",
- Config_Prop::Color, ModelAPI_ResultGroup::DEFAULT_COLOR());
- Config_PropManager::registerProp("Visualization", "result_construction_color",
- "Construction color",
- Config_Prop::Color,
- ModelAPI_ResultConstruction::DEFAULT_COLOR());
- Config_PropManager::registerProp("Visualization", "result_part_color", "Part color",
- Config_Prop::Color, ModelAPI_ResultPart::DEFAULT_COLOR());
- Config_PropManager::registerProp("Visualization", "result_field_color", "Field color",
- Config_Prop::Color, ModelAPI_ResultField::DEFAULT_COLOR());
+ Config_PropManager::registerProp("Visualization", "selection_color", "Selection color",
+ Config_Prop::Color, "255,255,255");
if (ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "face-selection", true))
myViewerSelMode.append(TopAbs_FACE);
// Calling of loadCustomProps before activating module is required
// by Config_PropManger to restore user-defined path to plugins
ModuleBase_Preferences::loadCustomProps();
+ std::vector<int> aColor;
+ try {
+ aColor = Config_PropManager::color("Visualization", "selection_color");
+ }
+ catch (...) {
+ }
+ if (aColor.size() == 3)
+ myDisplayer->setSelectionColor(aColor);
+
createModule();
#ifndef HAVE_SALOME
// Add commands to a file menu
- aAction = salomeConnector()->addDesktopCommand("SAVEAS_CMD", tr("Export native..."),
+ // Import sub-menu
+ aAction = salomeConnector()->addDesktopCommand("OPEN_CMD", tr("Part set..."),
+ tr("Import native file"),
+ QIcon(), QKeySequence(),
+ false, "MEN_DESK_FILE", tr("Import"), 10, 10);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onOpen()));
+
+ aAction = salomeConnector()->addDesktopCommand("IMPORT_PART_CMD", tr("Part..."),
+ tr("Import structure of a part"),
+ QIcon(), QKeySequence(),
+ false, "MEN_DESK_FILE", tr("Import"), 10, 10);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onImportPart()));
+
+ aAction = salomeConnector()->addDesktopCommand("IMPORT_SHAPE_CMD", tr("From CAD format..."),
+ tr("Import shape from a CAD format file"),
+ ModuleBase_IconFactory::loadIcon("icons/Exchange/import.png"),
+ QKeySequence(), false, "MEN_DESK_FILE", tr("Import"), 10, 10);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onImportShape()));
+
+ aAction = salomeConnector()->addDesktopCommand("IMPORT_IMAGE_CMD", tr("Picture..."),
+ tr("Import a picture from an image file"),
+ QIcon(),
+ QKeySequence(), false, "MEN_DESK_FILE", tr("Import"), 10, 10);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onImportImage()));
+
+ // Export sub-menu
+ aAction = salomeConnector()->addDesktopCommand("SAVEAS_CMD", tr("Part set..."),
tr("Export the current document into a native file"),
QIcon(), QKeySequence(),
- false, "MEN_DESK_FILE");
+ false, "MEN_DESK_FILE", tr("Export"), 10, 11);
connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onSaveAs()));
- aAction = salomeConnector()->addDesktopCommand("OPEN_CMD", tr("Import native..."),
- tr("Import native file"),
- QIcon(), QKeySequence(),
- false, "MEN_DESK_FILE");
- connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onOpen()));
- salomeConnector()->addDesktopMenuSeparator("MEN_DESK_FILE");
+ aAction = salomeConnector()->addDesktopCommand("EXPORT_PART_CMD", tr("Part..."),
+ tr("Export a part of the current document into a file"),
+ QIcon(), QKeySequence(),
+ false, "MEN_DESK_FILE", tr("Export"), 10, 11);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onExportPart()));
+
+ aAction = salomeConnector()->addDesktopCommand("EXPORT_SHAPE_CMD", tr("To CAD format..."),
+ tr("Export shape to a CAD format file"),
+ ModuleBase_IconFactory::loadIcon("icons/Exchange/export.png"),
+ QKeySequence(), false, "MEN_DESK_FILE", tr("Export"), 10, 11);
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onExportShape()));
#else
// File commands group
//******************************************************
void XGUI_Workshop::onAcceptActionClicked()
{
- QAction* anAction = dynamic_cast<QAction*>(sender());
XGUI_OperationMgr* anOperationMgr = operationMgr();
if (anOperationMgr) {
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
(anOperationMgr->currentOperation());
if (aFOperation) {
- //if (errorMgr()->canProcessClick(anAction, aFOperation->feature()))
myOperationMgr->commitOperation();
}
}
//******************************************************
void XGUI_Workshop::onAcceptPlusActionClicked()
{
- QAction* anAction = dynamic_cast<QAction*>(sender());
XGUI_OperationMgr* anOperationMgr = operationMgr();
if (anOperationMgr) {
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
//******************************************************
-void XGUI_Workshop::onHelpActionClicked()
+void XGUI_Workshop::onHelpActionClicked() const
{
XGUI_OperationMgr* anOperationMgr = operationMgr();
if (anOperationMgr) {
ModuleBase_Operation* aOperation = anOperationMgr->currentOperation();
if (aOperation) {
- QString aHelpPage = aOperation->helpFileName();
- if (!aHelpPage.isEmpty()) {
- QString aDocDir;
- const QChar aSep = QDir::separator();
+ showHelpPage(aOperation->helpFileName());
+ }
+ }
+}
+
+void XGUI_Workshop::showHelpPage(const QString& thePage) const
+{
+ if (!thePage.isEmpty()) {
+ QString aDocDir;
+ const QChar aSep = QDir::separator();
// QString platform;
// SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
//#ifdef WIN32
// QString aBrowserName = aResMgr->stringValue("ExternalBrowser", platform);
#ifdef HAVE_SALOME
- QString aDir(getenv("SHAPER_ROOT_DIR"));
- if (!aDir.isEmpty()) {
- aDocDir = aDir + aSep + "share" + aSep + "doc" + aSep +
- "salome" + aSep + "gui" + aSep + "SHAPER";
- }
+ QString aDir(getenv("SHAPER_ROOT_DIR"));
+ if (!aDir.isEmpty()) {
+ aDocDir = aDir + aSep + "share" + aSep + "doc" + aSep +
+ "salome" + aSep + "gui" + aSep + "SHAPER";
+ }
#else
- QString aDir(getenv("CADBUILDER_ROOT_DIR"));
- aDocDir = aDir + aSep + "doc" + aSep + "gui";
+ QString aDir(getenv("CADBUILDER_ROOT_DIR"));
+ aDocDir = aDir + aSep + "doc" + aSep + "gui";
#endif
- QString aFileName = aDocDir + aSep + aHelpPage;
- if (QFile::exists(aFileName)) {
- QUrl aUrl = QUrl::fromLocalFile(aFileName);
- QDesktopServices::openUrl(aUrl);
- }
+ QString aFileName = aDocDir + aSep + thePage;
+ if (QFile::exists(aFileName)) {
+#ifdef HAVE_SALOME
+ SUIT_Application* app = SUIT_Session::session()->activeApplication();
+ if (app)
+ app->onHelpContextModule("SHAPER", aFileName);
+ else {
+ QUrl aUrl = QUrl::fromLocalFile(aFileName);
+ QDesktopServices::openUrl(aUrl);
}
+#else
+ QUrl aUrl = QUrl::fromLocalFile(aFileName);
+ QDesktopServices::openUrl(aUrl);
+#endif
}
}
}
if (!aFOperation)
return;
- showPanel(myPropertyPanel);
myPropertyPanel->cleanContent();
QList<ModuleBase_ModelWidget*> aWidgets;
- if (!module()->createWidgets(theOperation, aWidgets)) {
- QString aXmlRepr = aFOperation->getDescription()->xmlRepresentation();
+ QString aXmlRepr = aFOperation->getDescription()->xmlRepresentation();
+ if (!module()->createWidgets(aFOperation->feature(), aXmlRepr, aWidgets)) {
ModuleBase_WidgetFactory aFactory(aXmlRepr.toStdString(), myModuleConnector);
aFactory.createWidget(myPropertyPanel->contentWidget());
aWidgets = aFactory.getModelWidgets();
myModule->propertyPanelDefined(theOperation);
#ifndef DEBUG_FEATURE_NAME
- myPropertyPanel->setWindowTitle(theOperation->getDescription()->description());
+ myPropertyPanel->setWindowTitle(ModuleBase_Tools::translate("workshop",
+ theOperation->getDescription()->description().toStdString()));
#else
std::string aFeatureName = aFeature->name();
myPropertyPanel->setWindowTitle(QString("%1: %2")
- .arg(theOperation->getDescription()->description())
- .arg(aFeatureName.c_str()));
+ .arg(translate(theOperation->getDescription()->description()))
+ .arg(translate(aFeatureName.c_str())));
#endif
myErrorMgr->setPropertyPanel(myPropertyPanel);
+ if (Config_PropManager::boolean("Windows", "use_hide_faces_panel")) {
+ theOperation->setHideFacesVisible(myFacesPanel->isVisible());
+ if (aFeatureInfo.get() && aFeatureInfo->isHideFacesPanel() && !myFacesPanel->isVisible())
+ myFacesPanel->show();
+ }
+ showPanel(myPropertyPanel);
}
//******************************************************
}
}
activateObjectsSelection(anObjects);
+
+ if (Config_PropManager::boolean("Windows", "use_hide_faces_panel")) {
+ if (!theOperation->isHideFacesVisible())
+ myFacesPanel->close();
+ }
}
//******************************************************
}
//show file dialog, check if readable and open
- QString aFile = QFileDialog::getOpenFileName(desktop(), tr("Open file"), QString(), MyFilter);
+ qreal aRatio = ModuleBase_Tools::currentPixelRatio();
+ // If the ratio is > 1 (HD screen) then QT has a bug in
+ // displaying of system open file dialog (too small)
+ QString aFile = QFileDialog::getOpenFileName(desktop(), tr("Open file"), QString(), MyFilter,
+ Q_NULLPTR, ((aRatio > 1)? QFileDialog::DontUseNativeDialog : QFileDialog::Options()));
if (!aFile.isNull())
openFile(aFile);
}
#ifdef _DEBUG
bool aNewPart = Config_PropManager::boolean("Plugins", "create_part_by_start");
if (aNewPart) {
-
- DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
int aSize = aRootDoc->size(ModelAPI_ResultPart::group());
if (aSize > 0 ) {
- ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), 0);
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
+ ObjectPtr anObject = aRootDoc->object(ModelAPI_ResultPart::group(), 0);
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anObject);
if (aPart.get())
aPart->activate();
}
}
#endif
+ int anActivationId =
+ ModuleBase_Preferences::resourceMgr()->integerValue("General", "part_activation_study", -1);
+ int aSize = aRootDoc->size(ModelAPI_ResultPart::group());
+
+ if (anActivationId == 0 && aSize > 0) {
+ ObjectPtr anObject = aRootDoc->object(ModelAPI_ResultPart::group(), aSize - 1);
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anObject);
+ if (aPart.get()) {
+ aPart->activate();
+ ModuleBase_Tools::setDisplaying(aPart);
+ }
+ }
+ else if (anActivationId == 1) {
+ for (int anIndex = 0; anIndex < aSize; ++anIndex) {
+ ObjectPtr anObject = aRootDoc->object(ModelAPI_ResultPart::group(), anIndex);
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(anObject);
+ if (aPart.get()) {
+ aPart->activate();
+ ModuleBase_Tools::setDisplaying(aPart);
+
+ if (anIndex < aSize - 1) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ aMgr->startOperation("Activation");
+ aMgr->setActiveDocument(aMgr->moduleDocument());
+ aMgr->finishOperation();
+ updateCommandStatus();
+ viewer()->update();
+ }
+ }
+ }
+ }
QApplication::restoreOverrideCursor();
}
QMdiSubWindow* aWnd = myMainWindow->viewer()->createView();
aWnd->showMaximized();
updateCommandStatus();
+ PyConsole_Console* aConsole = myMainWindow->pythonConsole();
+ connect(aConsole, SIGNAL(scriptLoaded()), SLOT(updateCommandStatus()));
#endif
myContextMenuMgr->connectViewer();
QApplication::restoreOverrideCursor();
ModuleBase_Preferences::editPreferences(aModif);
if (aModif.size() > 0) {
QString aSection;
- foreach (ModuleBase_Pref aPref, aModif)
- {
+ foreach (ModuleBase_Pref aPref, aModif) {
aSection = aPref.first;
if (aSection == ModuleBase_Preferences::VIEWER_SECTION) {
myMainWindow->viewer()->updateFromResources();
myMainWindow->menuObject()->updateFromResources();
}
}
+ std::vector<int> aColor;
+ try {
+ aColor = Config_PropManager::color("Visualization", "selection_color");
+ }
+ catch (...) {
+ }
+ if (aColor.size() == 3)
+ displayer()->setSelectionColor(aColor);
+
displayer()->redisplayObjects();
}
}
void XGUI_Workshop::onTrihedronVisibilityChanged(bool theState)
{
XGUI_Displayer* aDisplayer = displayer();
- if (aDisplayer)
+ if (aDisplayer) {
aDisplayer->displayTrihedron(theState);
+ aDisplayer->updateViewer();
+ }
}
//******************************************************
{
if(!myOperationMgr->abortAllOperations(XGUI_OperationMgr::XGUI_InformationMessage))
return false;
+ qreal aRatio = ModuleBase_Tools::currentPixelRatio();
myCurrentFile = QFileDialog::getSaveFileName(desktop(), tr("Select name to save file..."),
- QString(), MyFilter2);
+ QString(), MyFilter2,
+ Q_NULLPTR, ((aRatio > 1) ? QFileDialog::DontUseNativeDialog : QFileDialog::Options()));
if (!myCurrentFile.isNull()) {
if (!myCurrentFile.endsWith(MyExtension)) {
myCurrentFile += MyExtension;
if (anActiveWidget->processAction(theActionType, aParam))
return;
}
+ else
+ {
+ XGUI_FacesPanel * anFacePannel = facesPanel();
+ if(ActionUndo == theActionType && anFacePannel->isActivePanel())
+ {
+ anFacePannel->processUndo();
+ return;
+ }
+ }
// the viewer update should be blocked in order to avoid the features blinking. For the created
// feature a results are created, the flush of the created signal caused the viewer redisplay for
// each created result. After a redisplay signal is flushed. So, the viewer update is blocked
// until redo of all possible objects happens
bool isUpdateEnabled = myDisplayer->enableUpdateViewer(false);
+ int aTimes = theTimes;
SessionPtr aMgr = ModelAPI_Session::get();
if (aMgr->isOperation()) {
XGUI_OperationMgr* aOpMgr = operationMgr();
/// this is important for nested operations
/// when sketch operation is active, this condition is false and
/// the sketch operation is not aborted
- if (aOpMgr->canStopOperation(aOpMgr->currentOperation()))
+ if (aOpMgr->canStopOperation(aOpMgr->currentOperation())) {
aOpMgr->abortOperation(aOpMgr->currentOperation());
+ aTimes--;
+ }
else
{
myDisplayer->enableUpdateViewer(isUpdateEnabled);
std::list<std::string> anActionList = theActionType == ActionUndo ? aMgr->undoList()
: aMgr->redoList();
std::list<std::string>::const_iterator aIt = anActionList.cbegin();
- for (int i = 0; (i < theTimes) && (aIt != anActionList.cend()); ++i, ++aIt) {
+ for (int i = 0; (i < aTimes) && (aIt != anActionList.cend()); ++i, ++aIt) {
if (theActionType == ActionUndo)
aMgr->undo();
else
aMgr->redo();
- if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
+ if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND ||
+ QString((*aIt).c_str()) == MOVE_TO_END_SPLIT_COMMAND)
myObjectBrowser->rebuildDataTree();
}
operationMgr()->updateApplyOfOperations();
void XGUI_Workshop::onWidgetObjectUpdated()
{
operationMgr()->onValidateOperation();
+ myDisplayer->updateViewer();
+}
+
+//******************************************************
+void XGUI_Workshop::onImportPart()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anImportPartOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_ImportPart::ID()));
+ anImportPartOp->setHelpFileName(QString("ExchangePlugin") + QDir::separator() +
+ "importFeature.html");
+ myPropertyPanel->updateApplyPlusButton(anImportPartOp->feature());
+ operationMgr()->startOperation(anImportPartOp);
+ }
+}
+
+//******************************************************
+void XGUI_Workshop::onImportShape()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anImportOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_Import::ID()));
+ anImportOp->setHelpFileName(QString("ExchangePlugin") + QDir::separator() +
+ "importFeature.html");
+ myPropertyPanel->updateApplyPlusButton(anImportOp->feature());
+ operationMgr()->startOperation(anImportOp);
+ }
+}
+
+//******************************************************
+void XGUI_Workshop::onImportImage()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anImportOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_Import_Image::ID()));
+ anImportOp->setHelpFileName(QString("ExchangePlugin") + QDir::separator() +
+ "importFeature.html");
+ myPropertyPanel->updateApplyPlusButton(anImportOp->feature());
+ operationMgr()->startOperation(anImportOp);
+ }
+}
+
+//******************************************************
+void XGUI_Workshop::onExportShape()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anExportOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_ExportFeature::ID()));
+ anExportOp->setHelpFileName(QString("ExchangePlugin") + QDir::separator() +
+ "exportFeature.html");
+ myPropertyPanel->updateApplyPlusButton(anExportOp->feature());
+ operationMgr()->startOperation(anExportOp);
+ }
+}
+
+//******************************************************
+void XGUI_Workshop::onExportPart()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anExportPartOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_ExportPart::ID()));
+ anExportPartOp->setHelpFileName(QString("ExchangePlugin") + QDir::separator() +
+ "exportFeature.html");
+ myPropertyPanel->updateApplyPlusButton(anExportPartOp->feature());
+ operationMgr()->startOperation(anExportPartOp);
+ }
}
//******************************************************
myObjectBrowser->initialize(myModule->rootNode());
myModule->customizeObjectBrowser(myObjectBrowser);
aObjDock->setWidget(myObjectBrowser);
+ aObjDock->setObjectName("Object browser");
connect(myObjectBrowser, SIGNAL(sizeChanged()), SLOT(onDockSizeChanged()));
hidePanel(myPropertyPanel); ///<! Invisible by default
- myFacesPanel = new XGUI_FacesPanel(aDesktop, myModuleConnector);
+ myFacesPanel = new XGUI_FacesPanel(aDesktop, this);
myActiveControlMgr->addSelector(new XGUI_FacesPanelSelector(myFacesPanel));
myFacesPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea |
Qt::BottomDockWidgetArea);
connect(myFacesPanel, SIGNAL(closed()), myFacesPanel, SLOT(onClosed()));
- myInspectionPanel = new XGUI_InspectionPanel(aDesktop, mySelector);
+ myInspectionPanel = new XGUI_InspectionPanel(aDesktop, this);
myInspectionPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
aDesktop->addDockWidget(Qt::RightDockWidgetArea, myInspectionPanel);
// in order to operation manager could process key events of the panel.
// otherwise they are ignored. It happens only if the same(activateWindow) is
// not happened by property panel activation(e.g. resume operation of Sketch)
- ModuleBase_Tools::setFocus(theDockWidget, "XGUI_Workshop::showPanel()");
+ //ModuleBase_Tools::setFocus(theDockWidget, "XGUI_Workshop::showPanel()");
}
//******************************************************
//**************************************************************
void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
{
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
if (theId == "DELETE_CMD")
deleteObjects();
else if (theId == "CLEAN_HISTORY_CMD")
cleanHistory();
- else if (theId == "MOVE_CMD")
- moveObjects();
+ else if (theId == "MOVE_CMD" || theId == "MOVE_SPLIT_CMD")
+ moveObjects(theId == "MOVE_SPLIT_CMD");
else if (theId == "COLOR_CMD")
- changeColor(aObjects);
+ changeColor(anObjects);
+ else if (theId == "AUTOCOLOR_CMD")
+ changeAutoColor(anObjects);
+ else if (theId == "ISOLINES_CMD")
+ changeIsoLines(anObjects);
+ else if (theId == "SHOW_ISOLINES_CMD") {
+ foreach(ObjectPtr aObj, anObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
+ if (aResult.get())
+ ModelAPI_Tools::showIsoLines(aResult, !ModelAPI_Tools::isShownIsoLines(aResult));
+ }
+ mySelector->clearSelection();
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ }
else if (theId == "DEFLECTION_CMD")
- changeDeflection(aObjects);
+ changeDeflection(anObjects);
else if (theId == "TRANSPARENCY_CMD")
- changeTransparency(aObjects);
+ changeTransparency(anObjects);
else if (theId == "SHOW_CMD") {
- showObjects(aObjects, true);
+ showObjects(anObjects, true);
mySelector->updateSelectionBy(ModuleBase_ISelection::Browser);
updateCommandStatus();
}
else if (theId == "HIDE_CMD") {
- showObjects(aObjects, false);
+ showObjects(anObjects, false);
updateCommandStatus();
}
else if (theId == "SHOW_ONLY_CMD") {
- showOnlyObjects(aObjects);
+ showOnlyObjects(anObjects);
mySelector->updateSelectionBy(ModuleBase_ISelection::Browser);
updateCommandStatus();
}
else if (theId == "SHADING_CMD")
- setDisplayMode(aObjects, XGUI_Displayer::Shading);
+ setDisplayMode(anObjects, XGUI_Displayer::Shading);
else if (theId == "WIREFRAME_CMD")
- setDisplayMode(aObjects, XGUI_Displayer::Wireframe);
+ setDisplayMode(anObjects, XGUI_Displayer::Wireframe);
else if (theId == "HIDEALL_CMD") {
QObjectPtrList aList = myDisplayer->displayedObjects();
foreach (ObjectPtr aObj, aList) {
setViewerSelectionMode(ModuleBase_ResultPrs::Sel_Result);
setViewerSelectionMode(TopAbs_COMPSOLID);
} else if (theId == "SHOW_RESULTS_CMD") {
- highlightResults(aObjects);
+ highlightResults(anObjects);
} else if (theId == "SHOW_FEATURE_CMD") {
- highlightFeature(aObjects);
+ highlightFeature(anObjects);
} else if (theId == "SET_VIEW_NORMAL_CMD") {
setNormalView();
} else if (theId == "SET_VIEW_INVERTEDNORMAL_CMD") {
}
#ifdef TINSPECTOR
else if (theId == "TINSPECTOR_VIEW") {
- Handle(CDF_Application) anApplication = CDF_Session::CurrentSession()->CurrentApplication();
+ Handle(TDocStd_Application) anApplication = ModelAPI_Session::get()->application();
if (!anApplication.IsNull())
{
if (!MyTCommunicator)
if (!facesPanel()->isObjectHiddenByPanel(*anObjectsIt))
continue;
aHiddenObjects.insert(*anObjectsIt);
- aHiddenObjectNames.append((*anObjectsIt)->data()->name().c_str());
+ aHiddenObjectNames.append(QString::fromStdWString((*anObjectsIt)->data()->name()));
}
if (aHiddenObjects.empty()) // in parameter objects there are no hidden objects in hide face
return true;
// allow the module to delete objects, do nothing if it has succeed
if (aModule->deleteObjects()) {
updateCommandStatus();
+ myDisplayer->updateViewer();
return;
}
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+ if (anObjects.isEmpty())
+ return;
+
if (!abortAllOperations())
return;
if (!(hasResult || hasFeature || hasParameter || hasFolder))
return;
+ // Remove from the list non-deletable objects: infinite constructions which are not in history
+ bool notDelete = true;
+ QObjectPtrList::iterator aIt;
+ for (aIt = anObjects.begin(); aIt != anObjects.end(); aIt++) {
+ ObjectPtr aObj = (*aIt);
+ ResultConstructionPtr aConstr = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aObj);
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
+ if (aFeature) {
+ notDelete = (!aFeature->isInHistory()) && (aConstr && aConstr->isInfinite());
+ if (notDelete) {
+ anObjects.removeAll(aObj);
+ aIt--;
+ }
+ }
+ }
// delete objects
std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
std::set<FeaturePtr> aFeatures;
bool aDone = false;
QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text() + " %1";
aDescription = aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
- ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
+ ModuleBase_Operation* anOpAction = new ModuleBase_Operation(aDescription, module());
operationMgr()->startOperation(anOpAction);
operationMgr()->commitOperation();
else
operationMgr()->abortOperation(operationMgr()->currentOperation());
+
+ myDisplayer->updateViewer();
}
//**************************************************************
if (!anUnusedObjects.empty()) {
QStringList aNames;
foreach (const FeaturePtr& aFeature, anUnusedObjects) {
- aNames.append(aFeature->name().c_str());
+ aNames.append(QString::fromStdWString(aFeature->name()));
}
aNames.sort();
QString anUnusedNames = aNames.join(", ");
QString anActionId = "CLEAN_HISTORY_CMD";
- QString aDescription = contextMenuMgr()->action(anActionId)->text();
+ QString aDescription = ModuleBase_Tools::translate("workshop",
+ contextMenuMgr()->action(anActionId)->text().toStdString());
QMessageBox aMessageBox(desktop());
aMessageBox.setWindowTitle(aDescription);
// 1. start operation
aDescription += "by deleting of " +
aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
- ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
+ ModuleBase_Operation* anOpAction = new ModuleBase_Operation(aDescription, module());
operationMgr()->startOperation(anOpAction);
// WORKAROUND, should be done before each object remove, if it presents in XGUI_DataModel tree
}
//**************************************************************
-void XGUI_Workshop::moveObjects()
+bool compareFeature(const FeaturePtr& theF1, const FeaturePtr& theF2) {
+ DocumentPtr aDoc = theF1->document();
+ return aDoc->index(theF1) < aDoc->index(theF2);
+}
+void XGUI_Workshop::moveObjects(const bool theSplit)
{
if (!abortAllOperations())
return;
SessionPtr aMgr = ModelAPI_Session::get();
- QString anActionId = "MOVE_CMD";
- QString aDescription = contextMenuMgr()->action(anActionId)->text();
- aMgr->startOperation(aDescription.toStdString());
-
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
// It is necessary to clear selection in order to avoid selection changed event during
// moving and negative consequences connected with processing of already moved items
if (!XGUI_Tools::canRemoveOrRename(desktop(), aFeatures))
return;
+ QString anActionId = theSplit ? "MOVE_CMD" : "MOVE_SPLIT_CMD";
+ QString aDescription = contextMenuMgr()->action(anActionId)->text();
+ aMgr->startOperation(aDescription.toStdString());
+
+ // Sort features by index in document
+ std::list<FeaturePtr> aFList(aFeatures.begin(), aFeatures.end());
+ aFList.sort(compareFeature);
+
DocumentPtr anActiveDocument = aMgr->activeDocument();
FeaturePtr aCurrentFeature = anActiveDocument->currentFeature(true);
- std::set<FeaturePtr>::const_iterator anIt = aFeatures.begin(), aLast = aFeatures.end();
+ std::list<FeaturePtr>::const_iterator anIt = aFList.begin(), aLast = aFList.end();
for (; anIt != aLast; anIt++) {
FeaturePtr aFeature = *anIt;
if (!aFeature.get() || !myModule->canApplyAction(aFeature, anActionId))
continue;
- anActiveDocument->moveFeature(aFeature, aCurrentFeature);
+ anActiveDocument->moveFeature(aFeature, aCurrentFeature, theSplit);
aCurrentFeature = anActiveDocument->currentFeature(true);
}
aMgr->finishOperation();
+ updateCommandStatus();
+ myViewerProxy->update();
}
//**************************************************************
std::dynamic_pointer_cast<ModelAPI_ResultPart>(aResult);
if (aResultPart.get() && aResultPart->partDoc().get()) {
// Recursion
- std::list<FeaturePtr> anAllFeatures = allFeatures(aResultPart->partDoc());
- aResultList.insert(aResultList.end(), anAllFeatures.begin(), anAllFeatures.end());
+ std::list<FeaturePtr> aPartFeatures = allFeatures(aResultPart->partDoc());
+ aResultList.insert(aResultList.end(), aPartFeatures.begin(), aPartFeatures.end());
}
}
DocumentPtr aDocument = theObject->document();
std::list<FeaturePtr> anAllFeatures = allFeatures(aDocument);
// find the object iterator
- std::list<FeaturePtr>::iterator aObjectIt =
+ std::list<FeaturePtr>::iterator anObjectIt =
std::find(anAllFeatures.begin(), anAllFeatures.end(), theObject);
- if (aObjectIt == anAllFeatures.end())
+ if (anObjectIt == anAllFeatures.end())
return aResult;
// find the current feature iterator
std::list<FeaturePtr>::iterator aCurrentIt =
if (aCurrentIt == anAllFeatures.end())
return aResult;
// check the right order
- if (std::distance(aObjectIt, anAllFeatures.end()) <=
+ if (std::distance(anObjectIt, anAllFeatures.end()) <=
std::distance(aCurrentIt, anAllFeatures.end()))
return aResult;
// exclude the object
- std::advance(aObjectIt, 1);
+ std::advance(anObjectIt, 1);
// include the current feature
std::advance(aCurrentIt, 1);
- return std::list<FeaturePtr>(aObjectIt, aCurrentIt);
+ return std::list<FeaturePtr>(anObjectIt, aCurrentIt);
}
//******************************************************
{
QString anActionId = "MOVE_CMD";
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
QObjectPtrList aValidatedObjects;
- foreach (ObjectPtr aObject, aObjects) {
- if (!myModule->canApplyAction(aObject, anActionId))
+ foreach (ObjectPtr anObject, anObjects) {
+ if (!myModule->canApplyAction(anObject, anActionId))
continue;
// To be moved feature should be in active document
- if (aObject->document() != ModelAPI_Session::get()->activeDocument())
+ if (anObject->document() != ModelAPI_Session::get()->activeDocument())
continue;
- aValidatedObjects.append(aObject);
+ aValidatedObjects.append(anObject);
}
- if (aValidatedObjects.size() != aObjects.size())
- aObjects = aValidatedObjects;
+ if (aValidatedObjects.size() != anObjects.size())
+ anObjects = aValidatedObjects;
- bool aCanMove = !aObjects.empty();
+ bool aCanMove = !anObjects.empty();
- QObjectPtrList::const_iterator anIt = aObjects.begin(), aLast = aObjects.end();
+ QObjectPtrList::const_iterator anIt = anObjects.begin(), aLast = anObjects.end();
for (; anIt != aLast && aCanMove; anIt++) {
- ObjectPtr aObject = *anIt;
- if (!aObject.get() || !aObject->data().get() || !aObject->data()->isValid()) {
+ ObjectPtr anObject = *anIt;
+ if (!anObject.get() || !anObject->data().get() || !anObject->data()->isValid()) {
aCanMove = false;
break;
}
- FeaturePtr aFeat = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
+ FeaturePtr aFeat = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
// only groups can be moved to the end for now (#2451)
if (aFeat.get() && aFeat->getKind() != "Group") {
aCanMove = false;
}
// 1. Get features placed between selected and current in the document
- std::list<FeaturePtr> aFeaturesBetween = toCurrentFeatures(aObject);
- // if aFeaturesBetween is empty it means wrong order or aObject is the current feature
+ std::list<FeaturePtr> aFeaturesBetween = toCurrentFeatures(anObject);
+ // if aFeaturesBetween is empty it means wrong order or anObject is the current feature
if (aFeaturesBetween.empty())
aCanMove = false;
else {
std::set<FeaturePtr> aPlacedFeatures(aFeaturesBetween.begin(), aFeaturesBetween.end());
// 2. Get all reference features to the selected object in the document
std::set<FeaturePtr> aRefFeatures;
- ModuleBase_Tools::refsToFeatureInFeatureDocument(aObject, aRefFeatures);
+ ModuleBase_Tools::refsToFeatureInFeatureDocument(anObject, aRefFeatures);
if (aRefFeatures.empty())
continue;
if (theActionName == "COLOR_CMD" ||
theActionName == "DEFLECTION_CMD" ||
theActionName == "TRANSPARENCY_CMD") {
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
std::set<std::string> aTypes;
aTypes.insert(ModelAPI_ResultGroup::group());
aTypes.insert(ModelAPI_ResultBody::group());
aTypes.insert(ModelAPI_ResultPart::group());
- return hasResults(aObjects, aTypes);
+ return hasResults(anObjects, aTypes);
+ }
+ if (theActionName == "AUTOCOLOR_CMD") {
+
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+
+ std::set<std::string> aTypes;
+ aTypes.insert(ModelAPI_ResultGroup::group());
+
+ return hasResults(anObjects, aTypes);
}
return false;
}
-//******************************************************
-void setColor(ResultPtr theResult, const std::vector<int>& theColor)
-{
- if (!theResult.get())
- return;
- AttributeIntArrayPtr aColorAttr = theResult->data()->intArray(ModelAPI_Result::COLOR_ID());
- if (aColorAttr.get() != NULL) {
- if (!aColorAttr->size()) {
- aColorAttr->setSize(3);
+//**************************************************************
+void getDefaultColor(ObjectPtr theObject, const bool isEmptyColorValid,
+ std::vector<int>& theColor)
+{
+ theColor.clear();
+ // get default color from the preferences manager for the given result
+ if (theColor.empty()) {
+ std::string aSection, aName, aDefault;
+ theObject->colorConfigInfo(aSection, aName, aDefault);
+ if (!aSection.empty() && !aName.empty()) {
+ theColor = Config_PropManager::color(aSection, aName);
}
- aColorAttr->setValue(0, theColor[0]);
- aColorAttr->setValue(1, theColor[1]);
- aColorAttr->setValue(2, theColor[2]);
}
- static const Events_ID kRedisplayEvent =
- Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendUpdated(theResult, kRedisplayEvent);
+ if (!isEmptyColorValid && theColor.empty()) {
+ // all AIS objects, where the color is not set, are in black.
+ // The color should be defined in XML or set in the attribute
+ theColor = Config_PropManager::color("Visualization", "object_default_color");
+ Events_InfoMessage("XGUI_CustomPrs",
+ "A default color is not defined in the preferences for this kind of result").send();
+ }
}
//**************************************************************
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
if (aResult.get()) {
- XGUI_CustomPrs::getResultColor(aResult, aColor);
- }
- else {
- // TODO: remove the obtaining a color from the AIS object
- // this does not happen never because:
- // 1. The color can be changed only on results
- // 2. The result can be not visualized in the viewer(e.g. Origin Construction)
- AISObjectPtr anAISObj = myDisplayer->getAISObject(anObject);
- if (anAISObj.get()) {
- aColor.resize(3);
- anAISObj->getColor(aColor[0], aColor[1], aColor[2]);
+ ModelAPI_Tools::getColor(aResult, aColor);
+ if (aColor.empty()) {
+ AISObjectPtr anAISObj = myDisplayer->getAISObject(anObject);
+ if (anAISObj.get()) {
+ aColor.resize(3);
+ anAISObj->getColor(aColor[0], aColor[1], aColor[2]);
+ }
+ }
+ if (aColor.empty()) {
+ getDefaultColor(aResult, false, aColor);
}
}
- if (!aColor.empty())
- break;
}
if (aColor.size() != 3)
return;
// 3. abort the previous operation and start a new one
SessionPtr aMgr = ModelAPI_Session::get();
QString aDescription = contextMenuMgr()->action("COLOR_CMD")->text();
+
aMgr->startOperation(aDescription.toStdString());
// 4. set the value to all results
std::list<ResultPtr> allRes;
ModelAPI_Tools::allSubs(aBodyResult, allRes);
for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
- setColor(*aRes, !isRandomColor ? aColorResult : aDlg->getRandomColor());
+ ModelAPI_Tools::setColor(*aRes, !isRandomColor ? aColorResult : aDlg->getRandomColor());
}
}
- setColor(aResult, !isRandomColor ? aColorResult : aDlg->getRandomColor());
+ ModelAPI_Tools::setColor(aResult, !isRandomColor ? aColorResult : aDlg->getRandomColor());
}
}
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
aMgr->finishOperation();
updateCommandStatus();
+ myViewerProxy->update();
}
//**************************************************************
-void setDeflection(ResultPtr theResult, const double theDeflection)
+void XGUI_Workshop::changeAutoColor(const QObjectPtrList& theObjects)
{
- if (!theResult.get())
- return;
+ if (!abortAllOperations())
+ return;
- AttributeDoublePtr aDeflectionAttr = theResult->data()->real(ModelAPI_Result::DEFLECTION_ID());
- if (aDeflectionAttr.get() != NULL)
- aDeflectionAttr->setValue(theDeflection);
- static const Events_ID kRedisplayEvent =
- Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendUpdated(theResult, kRedisplayEvent);
-}
+ std::vector<int> aColor;
-//**************************************************************
-void setTransparency(ResultPtr theResult, double theTransparency)
-{
- if (!theResult.get())
- return;
+ // abort the previous operation and start a new one
+ SessionPtr aMgr = ModelAPI_Session::get();
+ QString aDescription = contextMenuMgr()->action("AUTOCOLOR_CMD")->text();
+ aMgr->startOperation(aDescription.toStdString());
- AttributeDoublePtr anAttribute = theResult->data()->real(ModelAPI_Result::TRANSPARENCY_ID());
- if (anAttribute.get() != NULL)
- anAttribute->setValue(theTransparency);
- static const Events_ID kRedisplayEvent =
- Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendUpdated(theResult, kRedisplayEvent);
+ if (Config_PropManager::getAutoColorStatus()) {
+ contextMenuMgr()->action("AUTOCOLOR_CMD")->setText(tr("Auto color"));
+ Config_PropManager::setAutoColorStatus(false);
+ ModelAPI_Tools::findRandomColor(aColor, true);
+ } else {
+ // set the value to all results
+ foreach (ObjectPtr anObj, theObjects) {
+ DocumentPtr aDocument = anObj->document();
+ std::list<FeaturePtr> anAllFeatures = allFeatures(aDocument);
+ // find the object iterator
+ std::list<FeaturePtr>::iterator anObjectIt = anAllFeatures.begin();
+ for (; anObjectIt != anAllFeatures.end(); ++ anObjectIt) {
+ FeaturePtr aFeature = *anObjectIt;
+ if (aFeature.get()) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aIt;
+ for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
+ ResultPtr aGroupResult = *aIt;
+ if (aGroupResult.get() &&
+ aGroupResult->groupName() == ModelAPI_ResultGroup::group()) {
+ ModelAPI_Tools::findRandomColor(aColor);
+ ModelAPI_Tools::setColor(aGroupResult, aColor);
+ }
+ }
+ }
+ }
+ }
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ aMgr->finishOperation();
+ updateCommandStatus();
+ myViewerProxy->update();
+ contextMenuMgr()->action("AUTOCOLOR_CMD")->setText(tr("Disable auto color"));
+ Config_PropManager::setAutoColorStatus(true);
+ }
}
//**************************************************************
if (aBodyResult.get() != NULL) { // change property for all sub-solids
std::list<ResultPtr> allRes;
ModelAPI_Tools::allSubs(aBodyResult, allRes);
- for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
- setTransparency(*aRes, theTransparency);
+ std::list<ResultPtr>::iterator aRes;
+ for(aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
+ ModelAPI_Tools::setTransparency(*aRes, theTransparency);
}
}
- setTransparency(aResult, theTransparency);
+ ModelAPI_Tools::setTransparency(aResult, theTransparency);
+ }
+ }
+}
+
+//**************************************************************
+double getDefaultDeflection(const ObjectPtr& theObject)
+{
+ double aDeflection = -1;
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
+ if (aResult.get()) {
+ bool isConstruction = false;
+
+ std::string aResultGroup = aResult->groupName();
+ if (aResultGroup == ModelAPI_ResultConstruction::group())
+ isConstruction = true;
+ else if (aResultGroup == ModelAPI_ResultBody::group()) {
+ GeomShapePtr aGeomShape = aResult->shape();
+ if (aGeomShape.get()) {
+ // if the shape could not be exploded on faces, it contains only wires, edges, and vertices
+ // correction of deviation for them should not influence to the application performance
+ GeomAPI_ShapeExplorer anExp(aGeomShape, GeomAPI_Shape::FACE);
+ isConstruction = !anExp.more();
+ }
}
+ if (isConstruction)
+ aDeflection = Config_PropManager::real("Visualization", "construction_deflection");
+ else
+ aDeflection = Config_PropManager::real("Visualization", "body_deflection");
}
+ return aDeflection;
}
//**************************************************************
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
if (aResult.get()) {
- aDeflection = XGUI_CustomPrs::getResultDeflection(aResult);
+ aDeflection = ModelAPI_Tools::getDeflection(aResult);
+ if (aDeflection < 0)
+ aDeflection = getDefaultDeflection(aResult);
}
else {
// TODO: remove the obtaining a property from the AIS object
std::list<ResultPtr> allRes;
ModelAPI_Tools::allSubs(aBodyResult, allRes);
for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
- setDeflection(*aRes, aDeflection);
+ ModelAPI_Tools::setDeflection(*aRes, aDeflection);
}
}
- setDeflection(aResult, aDeflection);
+ ModelAPI_Tools::setDeflection(aResult, aDeflection);
}
}
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
aMgr->finishOperation();
updateCommandStatus();
}
+//**************************************************************
+double getDefaultTransparency(const ResultPtr& theResult)
+{
+ return Config_PropManager::integer("Visualization", "shaper_default_transparency") / 100.;
+}
+
//**************************************************************
void XGUI_Workshop::changeTransparency(const QObjectPtrList& theObjects)
{
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
if (aResult.get()) {
- aCurrentValue = XGUI_CustomPrs::getResultTransparency(aResult);
+ aCurrentValue = ModelAPI_Tools::getTransparency(aResult);
+ if (aCurrentValue < 0)
+ aCurrentValue = getDefaultTransparency(aResult);
}
if (aCurrentValue > 0)
break;
// 2. show the dialog to change the value
XGUI_PropertyDialog* aDlg = new XGUI_PropertyDialog(desktop());
- aDlg->setWindowTitle("Transparency");
+ aDlg->setWindowTitle(tr("Transparency"));
XGUI_TransparencyWidget* aTransparencyWidget = new XGUI_TransparencyWidget(aDlg);
connect(aTransparencyWidget, SIGNAL(transparencyValueChanged()),
this, SLOT(onTransparencyValueChanged()));
QString aDescription = contextMenuMgr()->action("TRANSPARENCY_CMD")->text();
aMgr->startOperation(aDescription.toStdString());
- if (aDlg->exec() != QDialog::Accepted) {
+ if (aDlg->exec() == QDialog::Accepted) {
+ // 4. set the value to all results
+ aCurrentValue = aTransparencyWidget->getValue();
+ setTransparency(aCurrentValue, theObjects);
+ aMgr->finishOperation();
+ } else {
aMgr->abortOperation();
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
- return;
}
- // 4. set the value to all results
- aCurrentValue = aTransparencyWidget->getValue();
- setTransparency(aCurrentValue, theObjects);
- aMgr->finishOperation();
updateCommandStatus();
}
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
setTransparency(aTransparencyWidget->getValue(), anObjects);
- Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ static const Events_ID kRedisplayEvent =
+ Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+ Events_Loop::loop()->flush(kRedisplayEvent);
+
+ myViewerProxy->update();
}
myObjectBrowser->updateAllIndexes();
updateColorScaleVisibility();
+ displayer()->updateViewer();
}
//**************************************************************
// Necessary for update icons in ObjectBrowser on Linux
myObjectBrowser->updateAllIndexes();
updateColorScaleVisibility();
+ displayer()->updateViewer();
}
//**************************************************************
void XGUI_Workshop::updateColorScaleVisibility()
{
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
viewer()->setColorScaleShown(false);
- if (aObjects.size() == 1) {
+ if (anObjects.size() == 1) {
FieldStepPtr aStep =
- std::dynamic_pointer_cast<ModelAPI_ResultField::ModelAPI_FieldStep>(aObjects.first());
+ std::dynamic_pointer_cast<ModelAPI_ResultField::ModelAPI_FieldStep>(anObjects.first());
if (aStep.get() && myDisplayer->isVisible(aStep)) {
AISObjectPtr aAisPtr = myDisplayer->getAISObject(aStep);
Handle(AIS_InteractiveObject) aIO = aAisPtr->impl<Handle(AIS_InteractiveObject)>();
aPrs->dataRange(aMin, aMax);
myViewerProxy->setColorScaleRange(aMin, aMax);
}
- myViewerProxy->setColorScaleTitle(aStep->name().c_str());
+ myViewerProxy->setColorScaleTitle(QString::fromStdWString(aStep->name()));
myViewerProxy->setColorScaleShown(true);
}
}
GeomShapePtr aPlanarFace;
foreach(ModuleBase_ViewerPrsPtr aPrs, aPrsList) {
GeomShapePtr aShape = aPrs->shape();
- if (aShape.get() && aShape->isPlanar()) {
+ if (aShape.get() && aShape->isFace() && aShape->isPlanar()) {
aPlanarFace = aShape;
break;
}
aFace->computeSize(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
Handle(V3d_View) aView = myViewerProxy->activeView();
- double aScale = aView->Scale();
aView->SetAt(aPos->x(), aPos->y(), aPos->z());
aView->SetProj(aNormal->x(), aNormal->y(), aNormal->z());
Bnd_Box aBox;
void XGUI_Workshop::registerValidators() const
{
SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
+ MAYBE_UNUSED ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
}
//**************************************************************
aDocs.append(aMgr->moduleDocument());
foreach(DocumentPtr aDoc, aDocs) {
- synchronizeGroupInViewer(aDoc, ModelAPI_ResultConstruction::group(), false);
- synchronizeGroupInViewer(aDoc, ModelAPI_ResultBody::group(), false);
- synchronizeGroupInViewer(aDoc, ModelAPI_ResultPart::group(), false);
- synchronizeGroupInViewer(aDoc, ModelAPI_ResultGroup::group(), false);
+ synchronizeGroupInViewer(aDoc, false);
}
}
//******************************************************
void XGUI_Workshop::synchronizeGroupInViewer(const DocumentPtr& theDoc,
- const std::string& theGroup,
bool theUpdateViewer)
{
- ObjectPtr aObj;
- int aSize = theDoc->size(theGroup);
+ FeaturePtr aFeature;
+ ResultPtr aRes;
+ int aSize = theDoc->numInternalFeatures();
for (int i = 0; i < aSize; i++) {
- aObj = theDoc->object(theGroup, i);
- if (aObj->isDisplayed()) {
- // Hide the presentation with an empty shape. But isDisplayed state of the object should not
- // be changed to the object becomes visible when the shape becomes not empty
- ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
- if (aRes.get() && (!aRes->shape().get() || aRes->shape()->isNull()))
- continue;
- ResultBodyPtr aResBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aObj);
- if (aResBody.get())
- synchronizeResultTree(aResBody, false);
- else
- myDisplayer->display(aObj, false);
+ aFeature = theDoc->internalFeature(i);
+ if (!aFeature.get())
+ continue;
+ const std::list<ResultPtr>& aResults = aFeature->results();
+ std::list<ResultPtr>::const_iterator aIt;
+ aFeature->setDisplayed(false);
+ for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
+ aRes = (*aIt);
+ if (aRes->isDisplayed() && !aRes->isConcealed()) {
+ // Hide the presentation with an empty shape. But isDisplayed state of the object should not
+ // be changed to the object becomes visible when the shape becomes not empty
+ if (!aRes->shape().get() || aRes->shape()->isNull())
+ continue;
+ ResultBodyPtr aResBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aRes);
+ if (aResBody.get())
+ synchronizeResultTree(aResBody, false);
+ else {
+ if (aRes->isInHistory()) {
+ if (aRes->isDisplayed())
+ myDisplayer->display(aRes, false);
+ else
+ myDisplayer->erase(aRes, false);
+ }
+ else
+ aRes->setDisplayed(false);
+ }
+ }
}
}
if (theUpdateViewer)
if (aRes.get())
synchronizeResultTree(aRes, theUpdateViewer);
}
- else
- myDisplayer->display(theRes, theUpdateViewer);
+ else {
+ if (theRes->isDisplayed())
+ myDisplayer->display(theRes, theUpdateViewer);
+ else
+ myDisplayer->erase(theRes, theUpdateViewer);
+ }
}
#endif
void XGUI_Workshop::insertFeatureFolder()
{
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
- if (aObjects.isEmpty())
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+ if (anObjects.isEmpty())
return;
- ObjectPtr aObj = aObjects.first();
+ ObjectPtr aObj = anObjects.first();
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
if (aFeature.get() == NULL)
return;
SessionPtr aMgr = ModelAPI_Session::get();
bool isBlocked = aMgr->isAutoUpdateBlocked();
aMgr->blockAutoUpdate(!isBlocked);
+ myDisplayer->updateViewer();
}
void XGUI_Workshop::updateAutoComputeState()
{
SessionPtr aMgr = ModelAPI_Session::get();
- bool isComputeBlocked = aMgr->isAutoUpdateBlocked();
#ifdef HAVE_SALOME
// QAction* aUpdateCmd;
// QList<QAction*> aCommands = mySalomeConnector->commandList();
// aUpdateCmd->setIcon(isComputeBlocked? QIcon(":pictures/autoapply_stop.png") :
// QIcon(":pictures/autoapply_start.png"));
#else
+ bool isComputeBlocked = aMgr->isAutoUpdateBlocked();
AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
AppElements_Command* aUpdateCmd = aMenuBar->feature("AUTOCOMPUTE_CMD");
aUpdateCmd->button()->setIcon(isComputeBlocked? QIcon(":pictures/autoapply_stop.png") :
{
myActiveControlMgr->deactivateSelector(myActiveControlMgr->activeSelector());
}
+
+void XGUI_Workshop::changeIsoLines(const QObjectPtrList& theObjects)
+{
+ if (theObjects.isEmpty())
+ return;
+
+ QList<ResultPtr> aResultList;
+ ResultPtr aRes;
+ foreach(ObjectPtr aObj, theObjects) {
+ aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
+ if (aRes.get())
+ aResultList.append(aRes);
+ }
+
+ std::vector<int> aValues;
+ bool isVisible;
+ if (aResultList.size() == 1) {
+ ResultPtr aResult = aResultList.first();
+ if (aResult.get())
+ ModelAPI_Tools::getIsoLines(aResult, isVisible, aValues);
+ else
+ return;
+ }
+ if (aValues.size() == 0) {
+ aValues.push_back(1);
+ aValues.push_back(1);
+ }
+
+ if (!abortAllOperations())
+ return;
+
+ XGUI_PropertyDialog aDlg(desktop());
+ aDlg.setWindowTitle(tr("Number of Iso-lines"));
+
+ QWidget* aIsosWgt = new QWidget(&aDlg);
+ QFormLayout* aLayout = new QFormLayout(aIsosWgt);
+ ModuleBase_Tools::adjustMargins(aLayout);
+ aDlg.setContent(aIsosWgt);
+
+ QSpinBox* aUNb = new QSpinBox(&aDlg);
+ aUNb->setValue(aValues[0]);
+ aLayout->addRow("U:", aUNb);
+
+ QSpinBox* aVNb = new QSpinBox(&aDlg);
+ aVNb->setValue(aValues[1]);
+ aLayout->addRow("V:", aVNb);
+
+ if (aDlg.exec() == QDialog::Accepted) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ QString aDescription = contextMenuMgr()->action("ISOLINES_CMD")->text();
+ aMgr->startOperation(aDescription.toStdString());
+
+ aValues[0] = aUNb->value();
+ aValues[1] = aVNb->value();
+ foreach(ResultPtr aResult, aResultList) {
+ ModelAPI_Tools::setIsoLines(aResult, aValues);
+ }
+ mySelector->clearSelection();
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ aMgr->finishOperation();
+ updateCommandStatus();
+ }
+}
