-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2019 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
//
// 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
+// 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>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "XGUI_Workshop.h"
#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
#include <AppElements_Button.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_Object.h>
#include <ModelAPI_ResultBody.h>
-#include <ModelAPI_ResultCompSolid.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultParameter.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_Tools.h>
+#include <ModelAPI_ResultField.h>
//#include <PartSetPlugin_Part.h>
#include <Events_InfoMessage.h>
#include <Events_LongOp.h>
+#include <ExchangePlugin_ExportPart.h>
+#include <ExchangePlugin_ImportPart.h>
+
+#include <GeomAPI_Pnt.h>
+
#include <ModuleBase_IModule.h>
#include <ModuleBase_IViewer.h>
#include <ModuleBase_Operation.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 <ModuleBase_ResultPrs.h>
#include <ModuleBase_ActionIntParameter.h>
+#include <ModuleBase_IStepPrs.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <QToolButton>
#include <QAction>
#include <QDesktopWidget>
+#include <QProcess>
+#include <QDesktopServices>
#include <iterator>
//#define DEBUG_FEATURE_NAME
//#define DEBUG_CLEAN_HISTORY
+#ifdef HAVE_SALOME
+static QString MyFilter(QObject::tr("SHAPER files (*.shaper *.cadbld)"));
+static QString MyFilter2(QObject::tr("SHAPER files (*.shaper)"));
+static QString MyExtension(".shaper");
+#else
+static QString MyFilter(QObject::tr("CAD Builder files (*.cadbld);;All files (*.*)"));
+static QString MyFilter2(QObject::tr("CAD Builder files (*.cadbld)"));
+static QString MyExtension(".cadbld");
+#endif
+
+static QString MyImportPartFilter(QObject::tr("Part files (*.shaperpart);;All files (*.*)"));
+
+
//******************************************************
XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
: QObject(),
- myCurrentDir(QString()),
myModule(NULL),
mySalomeConnector(theConnector),
myPropertyPanel(0),
+ myInspectionPanel(0),
myFacesPanel(0),
myObjectBrowser(0),
myDisplayer(0)
myOperationMgr = new XGUI_OperationMgr(this, 0);
ModuleBase_IWorkshop* aWorkshop = moduleConnector();
// Has to be defined first in order to get errors and messages from other components
- myEventsListener = new XGUI_WorkshopListener(aWorkshop);
+ myEventsListener = new XGUI_WorkshopListener(this);
mySelectionActivate = new XGUI_SelectionActivate(aWorkshop);
SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
#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);
delete myDisplayer;
delete myDataModelXMLReader;
+ delete mySelectionActivate;
+ delete myMenuMgr;
+ clearTemporaryDir();
}
//******************************************************
// 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
QKeySequence::Undo, false,
"MEN_DESK_EDIT");
QString aToolBarTitle = tr( "INF_DESK_TOOLBAR_STANDARD" );
- salomeConnector()->addActionInToolbar( aAction,aToolBarTitle );
+ salomeConnector()->addActionInToolbar( aAction,aToolBarTitle );
connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onUndo()));
addHistoryMenu(aAction, SIGNAL(updateUndoHistory(const QList<ActionInfo>&)), SLOT(onUndo(int)));
salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
+ //aAction = salomeConnector()->addDesktopCommand("AUTOCOMPUTE_CMD", tr("Auto rebuild"),
+ // tr("Blocks immediate apply of modifications"),
+ // QIcon(":pictures/autoapply.png"), QKeySequence(),
+ // false, "MEN_DESK_EDIT");
+ //salomeConnector()->addActionInToolbar( aAction, aToolBarTitle );
+
+ //connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onAutoApply()));
+
+ salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
+
+
+ // Add commands to a file menu
aAction = salomeConnector()->addDesktopCommand("SAVEAS_CMD", tr("Export native..."),
tr("Export the current document into a native file"),
QIcon(), QKeySequence(),
connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onOpen()));
salomeConnector()->addDesktopMenuSeparator("MEN_DESK_FILE");
+ aAction = salomeConnector()->addDesktopCommand("EXPORT_PART_CMD", tr("Export part..."),
+ tr("Export a part of the current document into a file"),
+ QIcon(), QKeySequence(),
+ false, "MEN_DESK_FILE");
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onExportPart()));
+
+ aAction = salomeConnector()->addDesktopCommand("IMPORT_PART_CMD", tr("Import part..."),
+ tr("Import structure of a part"),
+ QIcon(), QKeySequence(),
+ false, "MEN_DESK_FILE");
+ connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onImportPart()));
+ salomeConnector()->addDesktopMenuSeparator("MEN_DESK_FILE");
+
#else
// File commands group
AppElements_MenuGroupPanel* aGroup = myMainWindow->menuObject()->generalPage();
QIcon(":pictures/open.png"), QKeySequence::Open);
aCommand->connectTo(this, SLOT(onOpen()));
+
+ aCommand = aGroup->addFeature("AUTOCOMPUTE_CMD", tr("Auto rebuild"),
+ tr("Blocks immediate apply of modifications"),
+ QIcon(":pictures/autoapply_start.png"), QKeySequence());
+ aCommand->setChecked(ModelAPI_Session::get()->isAutoUpdateBlocked());
+ aCommand->connectTo(this, SLOT(onAutoApply()));
+
aCommand = aGroup->addFeature("PREF_CMD", tr("Preferences"), tr("Edit preferences"),
QIcon(":pictures/preferences.png"), QKeySequence::Preferences);
aCommand->connectTo(this, SLOT(onPreferences()));
}
}
+//******************************************************
+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) {
+ if (myOperationMgr->commitOperation())
+ module()->launchOperation(aFOperation->id(), false);
+ }
+ }
+}
+
//******************************************************
void XGUI_Workshop::onPreviewActionClicked()
{
Events_Loop::loop()->send(aMsg);
}
+
+//******************************************************
+void XGUI_Workshop::onHelpActionClicked()
+{
+ 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();
+// QString platform;
+// SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
+//#ifdef WIN32
+// platform = "winapplication";
+//#else
+// platform = "application";
+//#endif
+// 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";
+ }
+#else
+ 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);
+ }
+ }
+ }
+ }
+}
+
+
//******************************************************
void XGUI_Workshop::deactivateActiveObject(const ObjectPtr& theObject, const bool theUpdateViewer)
{
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();
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
aFeatureInfo = aCommand->featureMessage();
#endif
bool anIsAutoPreview = true;
- if (aFeatureInfo.get())
+ if (aFeatureInfo.get()) {
anIsAutoPreview = aFeatureInfo->isAutoPreview();
- else {
+ theOperation->setHelpFileName(aFeatureInfo->helpFileName().c_str());
+ } else {
std::string aXmlCfg, aDescription;
module()->getXMLRepresentation(aFeatureKind, aXmlCfg, aDescription);
ModuleBase_WidgetFactory aFactory(aXmlCfg, moduleConnector());
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);
+ theOperation->setHideFacesVisible(myFacesPanel->isVisible());
+ if (aFeatureInfo.get() && aFeatureInfo->isHideFacesPanel() && !myFacesPanel->isVisible())
+ myFacesPanel->show();
+ showPanel(myPropertyPanel);
}
//******************************************************
if (theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
fillPropertyPanel(theOperation);
connectToPropertyPanel(true);
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (theOperation);
+ if (aFOperation)
+ myPropertyPanel->updateApplyPlusButton(aFOperation->feature());
+ else
+ myPropertyPanel->updateApplyPlusButton(FeaturePtr());
}
updateCommandStatus();
}
}
activateObjectsSelection(anObjects);
+
+ if (!theOperation->isHideFacesVisible())
+ myFacesPanel->hide();
}
//******************************************************
//save current file before close if modified
SessionPtr aSession = ModelAPI_Session::get();
if (aSession->isModified()) {
- //TODO(sbh): re-launch the app?
int anAnswer = QMessageBox::question(
desktop(), tr("Save current file"),
tr("The document is modified, save before opening another?"),
} else if (anAnswer == QMessageBox::Cancel) {
return;
}
- myCurrentDir = "";
+ myCurrentFile = QString();
}
//show file dialog, check if readable and open
- QString aDirectory = QFileDialog::getExistingDirectory(desktop(), tr("Select directory"));
- openDirectory(aDirectory);
+ 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);
}
//******************************************************
-void XGUI_Workshop::openDirectory(const QString& theDirectory)
+void XGUI_Workshop::openFile(const QString& theDirectory)
{
- myCurrentDir = theDirectory;
- if (myCurrentDir.isEmpty())
+ myCurrentFile = theDirectory;
+ if (myCurrentFile.isEmpty())
return;
- QFileInfo aFileInfo(myCurrentDir);
+ QFileInfo aFileInfo(myCurrentFile);
if (!aFileInfo.exists() || !aFileInfo.isReadable()) {
QMessageBox::critical(desktop(), tr("Warning"), tr("Unable to open the file."));
- myCurrentDir = "";
+ myCurrentFile = QString();
return;
}
module()->closeDocument();
SessionPtr aSession = ModelAPI_Session::get();
aSession->closeAll();
- aSession->load(myCurrentDir.toLatin1().constData());
+
+ clearTemporaryDir();
+ if (!XGUI_CompressFiles::uncompress(myCurrentFile, myTmpDir.path()))
+ return;
+
+ aSession->load(myTmpDir.path().toLatin1().constData());
myObjectBrowser->rebuildDataTree();
// Open first level of data tree
updateCommandStatus();
#ifndef HAVE_SALOME
- myMainWindow->setCurrentDir(myCurrentDir, true);
+ myMainWindow->setCurrentDir(myCurrentFile, true);
#endif
#ifdef _DEBUG
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;
- if (myCurrentDir.isEmpty()) {
+ if (myCurrentFile.isEmpty()) {
return onSaveAs();
}
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->isAutoUpdateBlocked())
+ aMgr->blockAutoUpdate(false);
+
std::list<std::string> aFiles;
- saveDocument(myCurrentDir, aFiles);
- updateCommandStatus();
+ // issue #2899: create a temporary directory, save and then remove it
+#ifdef HAVE_SALOME
+ std::string aTmpDir = XGUI_Tools::getTmpDirByEnv("SALOME_TMP_DIR");
+#else
+ std::string aTmpDir = XGUI_Tools::getTmpDirByEnv("");
+#endif
+ saveDocument(QString(aTmpDir.c_str()), aFiles);
+ bool aResult = XGUI_CompressFiles::compress(myCurrentFile, aFiles);
+ XGUI_Tools::removeTemporaryFiles(aTmpDir, aFiles);
+
+ if (aResult) {
+ updateCommandStatus();
#ifndef HAVE_SALOME
myMainWindow->setModifiedState(false);
#endif
- return true;
+ }
+ return aResult;
}
//******************************************************
{
if(!myOperationMgr->abortAllOperations(XGUI_OperationMgr::XGUI_InformationMessage))
return false;
- QFileDialog dialog(desktop());
- dialog.setWindowTitle(tr("Select directory to save files..."));
- dialog.setFileMode(QFileDialog::Directory);
- dialog.setFilter(QDir::AllDirs);
- dialog.setOptions(QFileDialog::HideNameFilterDetails | QFileDialog::ShowDirsOnly);
- dialog.setViewMode(QFileDialog::Detail);
-
- if (!dialog.exec()) {
- return false;
- }
-
- QString aTempDir = dialog.selectedFiles().first();
- QDir aDir(aTempDir);
- if (aDir.exists() && !aDir.entryInfoList(QDir::NoDotAndDotDot | QDir::AllEntries).isEmpty()) {
- int answer = QMessageBox::question(
- desktop(),
- // Title of the dialog which asks user if he wants to save study
- // in existing non-empty folder
- tr("Save"),
- tr("The directory already contains some files, save anyway?"),
- QMessageBox::Save | QMessageBox::Cancel);
- if (answer == QMessageBox::Cancel) {
- return false;
+ qreal aRatio = ModuleBase_Tools::currentPixelRatio();
+ myCurrentFile = QFileDialog::getSaveFileName(desktop(), tr("Select name to save file..."),
+ QString(), MyFilter2,
+ Q_NULLPTR, ((aRatio > 1) ? QFileDialog::DontUseNativeDialog : QFileDialog::Options()));
+ if (!myCurrentFile.isNull()) {
+ if (!myCurrentFile.endsWith(MyExtension)) {
+ myCurrentFile += MyExtension;
}
}
- myCurrentDir = aTempDir;
+ else
+ return false;
#ifndef HAVE_SALOME
- myMainWindow->setCurrentDir(myCurrentDir, false);
+ myMainWindow->setCurrentDir(myCurrentFile, false);
myMainWindow->setModifiedState(false);
#endif
return onSave();
void XGUI_Workshop::onUndo(int theTimes)
{
processUndoRedo(ActionUndo, theTimes);
+ myObjectBrowser->updateAllIndexes(1);
}
//******************************************************
void XGUI_Workshop::onRedo(int theTimes)
{
processUndoRedo(ActionRedo, theTimes);
+ myObjectBrowser->updateAllIndexes(1);
}
//******************************************************
if (aOpMgr->canStopOperation(aOpMgr->currentOperation()))
aOpMgr->abortOperation(aOpMgr->currentOperation());
else
+ {
+ myDisplayer->enableUpdateViewer(isUpdateEnabled);
return;
+ }
}
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
std::list<std::string> anActionList = theActionType == ActionUndo ? aMgr->undoList()
updateCommandStatus();
// unblock the viewer update functionality and make update on purpose
- if (theActionType == ActionRedo) {
- myDisplayer->enableUpdateViewer(isUpdateEnabled);
- myDisplayer->updateViewer();
- }
+ myDisplayer->enableUpdateViewer(isUpdateEnabled);
+ myDisplayer->updateViewer();
+ // Clear messages in status bar from previous operations if exists
+ setStatusBarMessage("");
}
//******************************************************
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()));
+ operationMgr()->startOperation(anImportPartOp);
+ }
+}
+
+//******************************************************
+void XGUI_Workshop::onExportPart()
+{
+ if (abortAllOperations()) {
+ ModuleBase_OperationFeature* anExportPartOp = dynamic_cast<ModuleBase_OperationFeature*>(
+ module()->createOperation(ExchangePlugin_ExportPart::ID()));
+ operationMgr()->startOperation(anExportPartOp);
+ }
}
//******************************************************
CREATE_FUNC crtInst = 0;
#ifdef WIN32
- HINSTANCE modLib = ::LoadLibrary((LPTSTR) qPrintable(libName));
+ HINSTANCE modLib = ::LoadLibraryA(qPrintable(libName));
if (!modLib) {
LPVOID lpMsgBuf;
::FormatMessage(
else
aCmd->setEnabled(myModule->canRedo());
}
+ else if (aId == "AUTOCOMPUTE_CMD") {
+ aCmd->setIcon(aMgr->isAutoUpdateBlocked() ?
+ QIcon(":pictures/autoapply_stop.png") :
+ QIcon(":pictures/autoapply_start.png"));
+ }
else
// Enable all commands
aCmd->setEnabled(true);
{
QDockWidget* aObjDock = new QDockWidget(theParent);
aObjDock->setAllowedAreas(Qt::LeftDockWidgetArea |
- Qt::RightDockWidgetArea |
- Qt::BottomDockWidgetArea);
+ Qt::RightDockWidgetArea);
aObjDock->setWindowTitle(tr("Object browser"));
aObjDock->setStyleSheet(
"::title { position: relative; padding-left: 5px; text-align: left center }");
myObjectBrowser = new XGUI_ObjectsBrowser(aObjDock, this);
- myObjectBrowser->setXMLReader(myDataModelXMLReader);
+ myObjectBrowser->initialize(myModule->rootNode());
myModule->customizeObjectBrowser(myObjectBrowser);
aObjDock->setWidget(myObjectBrowser);
+ connect(myObjectBrowser, SIGNAL(sizeChanged()), SLOT(onDockSizeChanged()));
+
myContextMenuMgr->connectObjectBrowser();
return aObjDock;
}
myPropertyPanel->setupActions(myActionsMgr);
myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
- Qt::RightDockWidgetArea |
- Qt::BottomDockWidgetArea);
+ Qt::RightDockWidgetArea);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
+
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, this);
+ myInspectionPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
+ Qt::RightDockWidgetArea);
+ aDesktop->addDockWidget(Qt::RightDockWidgetArea, myInspectionPanel);
+
+ myInspectionPanel->hide();
+
aDesktop->addDockWidget(
#ifdef HAVE_SALOME
Qt::RightDockWidgetArea,
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()));
QAction* aPreviewAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Preview);
connect(aPreviewAct, SIGNAL(triggered()), this, SLOT(onPreviewActionClicked()));
+ QAction* aHelpAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Help);
+ connect(aHelpAct, SIGNAL(triggered()), this, SLOT(onHelpActionClicked()));
+
connect(myPropertyPanel, SIGNAL(keyReleased(QObject*, QKeyEvent*)),
myOperationMgr, SLOT(onKeyReleased(QObject*, QKeyEvent*)));
connect(myPropertyPanel, SIGNAL(enterClicked(QObject*)),
// the property panel is active window of the desktop, when it is
// hidden, it is undefined which window becomes active. By this reason
// it is defined to perform the desktop as the active window.
- // in SALOME mode, workstack made the PyConsole the active window,
+ // in SALOME mode, work-stack made the PyConsole the active window,
// set the focus on it. As a result, shortcuts of the application, like
// are processed by this console. For example Undo actions.
// It is possible that this code is to be moved to SHAPER package
//******************************************************
void XGUI_Workshop::showObjectBrowser()
{
- if (!isSalomeMode())
+ if (!isSalomeMode()) {
myObjectBrowser->parentWidget()->show();
+ }
}
//******************************************************
changeColor(aObjects);
else if (theId == "DEFLECTION_CMD")
changeDeflection(aObjects);
-#ifdef USE_TRANSPARENCY
else if (theId == "TRANSPARENCY_CMD")
changeTransparency(aObjects);
-#endif
else if (theId == "SHOW_CMD") {
showObjects(aObjects, true);
mySelector->updateSelectionBy(ModuleBase_ISelection::Browser);
highlightResults(aObjects);
} else if (theId == "SHOW_FEATURE_CMD") {
highlightFeature(aObjects);
+ } else if (theId == "SET_VIEW_NORMAL_CMD") {
+ setNormalView();
+ } else if (theId == "SET_VIEW_INVERTEDNORMAL_CMD") {
+ setNormalView(true);
}
#ifdef TINSPECTOR
else if (theId == "TINSPECTOR_VIEW") {
#ifdef DEBUG_WITH_MESSAGE_REPORT
MyTCommunicator->RegisterPlugin("TKMessageView");
#endif
- MyTCommunicator->RegisterPlugin("SMBrowser"); // custom plugin to view ModelAPI
+ //MyTCommunicator->RegisterPlugin("SMBrowser"); // custom plugin to view ModelAPI
//MyTCommunicator->RegisterPlugin("TKSMBrowser"); // custom plugin to view ModelAPI
MyTCommunicator->Init(aParameters);
//**************************************************************
bool XGUI_Workshop::prepareForDisplay(const std::set<ObjectPtr>& theObjects) const
{
+ if (facesPanel()->isEmpty())
+ return true;
+
// generate container of objects taking into account sub elments of compsolid
std::set<ObjectPtr> anAllProcessedObjects;
for (std::set<ObjectPtr>::const_iterator anObjectsIt = theObjects.begin();
anObjectsIt != theObjects.end(); anObjectsIt++) {
ObjectPtr anObject = *anObjectsIt;
- ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(anObject);
+ ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anObject);
if (aCompRes.get()) {
- if (aCompRes->numberOfSubs(true) == 0)
+ std::list<ResultPtr> allRes;
+ ModelAPI_Tools::allSubs(aCompRes, allRes);
+ if (allRes.empty()) {
anAllProcessedObjects.insert(anObject);
- else {
- for (int i = 0; i < aCompRes->numberOfSubs(true); i++) {
- ResultPtr aSubRes = aCompRes->subResult(i, true);
- anAllProcessedObjects.insert(aCompRes->subResult(i, true));
+ } else {
+ for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
+ ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aRes);
+ if (aBody.get() && aBody->numberOfSubs() == 0)
+ anAllProcessedObjects.insert(aBody);
}
}
- }
- else
+ } else
anAllProcessedObjects.insert(anObject);
}
aHiddenObjects.insert(*anObjectsIt);
aHiddenObjectNames.append((*anObjectsIt)->data()->name().c_str());
}
- if (aHiddenObjects.empty())
+ if (aHiddenObjects.empty()) // in parameter objects there are no hidden objects in hide face
return true;
int anAnswer = QMessageBox::question(
desktop(), tr("Show object"),
tr("'%1'\n are hidden by %2:\nRemove objects from the panel to be displayed?")
- .arg(aHiddenObjectNames.join(',')).arg(facesPanel()->windowTitle(),
- QMessageBox::Yes | QMessageBox::No, QMessageBox::No));
+ .arg(aHiddenObjectNames.join(", ")).arg(facesPanel()->windowTitle()),
+ QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
bool aToBeDisplayed = anAnswer == QMessageBox::Yes;
if (aToBeDisplayed)
// allow the module to delete objects, do nothing if it has succeed
if (aModule->deleteObjects()) {
updateCommandStatus();
+ myDisplayer->updateViewer();
return;
}
bool hasFolder = false;
ModuleBase_Tools::checkObjects(anObjects, hasResult, hasFeature, hasParameter, hasCompositeOwner,
hasResultInHistory, hasFolder);
- if (!(hasFeature || hasParameter || hasFolder))
+ 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->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);
}
}
}
+ // remove results selected
+ std::list<ResultPtr> aResults;
+ for(QObjectPtrList::const_iterator anIt = anObjects.begin(); anIt != anObjects.end(); anIt++) {
+ ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(*anIt);
+ if (aRes.get() && aRes->data()->isValid() && !aRes->data()->isDeleted() &&
+ aRes->groupName() != ModelAPI_ResultGroup::group() && // don't remove groups and fields
+ aRes->groupName() != ModelAPI_ResultField::group()) // because they are badly selected
+ aResults.push_back(aRes);
+ }
+ if (!aResults.empty()) {
+ ModelAPI_Tools::removeResults(aResults);
+ }
if (aDone)
operationMgr()->commitOperation();
else
operationMgr()->abortOperation(operationMgr()->currentOperation());
+
+ myDisplayer->updateViewer();
}
//**************************************************************
ModelAPI_Tools::findAllReferences(aFeatures, aReferences, true, false);
// find for each object whether all reference values are in the map as key, that means that there
// is no other reference in the model to this object, so it might be removed by cleaning history
- // sk_1(ext_1, vertex_1) + (sk_3, bool_1) - cann't be deleted, dependency to bool_1
- // ext_1(bool_1, sk_3) - cann't be deleted, dependency to bool_1
+ // sk_1(ext_1, vertex_1) + (sk_3, bool_1) - can't be deleted, dependency to bool_1
+ // ext_1(bool_1, sk_3) - can't be deleted, dependency to bool_1
// vertex_1()
- // sk_2(ext_2) + (bool_1) - cann't be deleted, dependency to bool_1
- // ext_2(bool_1) - cann't be deleted, dependency to bool_1
+ // sk_2(ext_2) + (bool_1) - can't be deleted, dependency to bool_1
+ // ext_2(bool_1) - can't be deleted, dependency to bool_1
// sk_3()
// Information: bool_1 is not selected
std::set<FeaturePtr> anUnusedObjects;
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
}
//**************************************************************
+bool compareFeature(const FeaturePtr& theF1, const FeaturePtr& theF2) {
+ DocumentPtr aDoc = theF1->document();
+ return aDoc->index(theF1) < aDoc->index(theF2);
+}
void XGUI_Workshop::moveObjects()
{
if (!abortAllOperations())
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 = "MOVE_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))
aCurrentFeature = anActiveDocument->currentFeature(true);
}
aMgr->finishOperation();
+ updateCommandStatus();
}
//**************************************************************
bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theObjects)
{
- std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
std::set<FeaturePtr> aFeatures;
ModuleBase_Tools::convertToFeatures(theObjects, aFeatures);
QObjectPtrList::const_iterator anIt = aObjects.begin(), aLast = aObjects.end();
for (; anIt != aLast && aCanMove; anIt++) {
ObjectPtr aObject = *anIt;
+ if (!aObject.get() || !aObject->data().get() || !aObject->data()->isValid()) {
+ aCanMove = false;
+ break;
+ }
+ FeaturePtr aFeat = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
+ // only groups can be moved to the end for now (#2451)
+ if (aFeat.get() && aFeat->getKind() != "Group") {
+ aCanMove = false;
+ break;
+ }
+
// 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
{
bool aCanBeShaded = myDisplayer->canBeShaded(theObject);
if (!aCanBeShaded) {
- ResultCompSolidPtr aCompsolidResult =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObject);
- if (aCompsolidResult.get() != NULL) { // change colors for all sub-solids
- for(int i = 0; i < aCompsolidResult->numberOfSubs() && !aCanBeShaded; i++)
- aCanBeShaded = myDisplayer->canBeShaded(aCompsolidResult->subResult(i));
+ ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theObject);
+ if (aCompRes.get() != NULL) { // change colors for all sub-solids
+ std::list<ResultPtr> allRes;
+ ModelAPI_Tools::allSubs(aCompRes, allRes);
+ std::list<ResultPtr>::iterator aRes = allRes.begin();
+ for(; aRes != allRes.end() && !aCanBeShaded; aRes++) {
+ aCanBeShaded = myDisplayer->canBeShaded(*aRes);
+ }
}
}
return aCanBeShaded;
bool XGUI_Workshop::canChangeProperty(const QString& theActionName) const
{
if (theActionName == "COLOR_CMD" ||
- theActionName == "DEFLECTION_CMD"
-#ifdef USE_TRANSPARENCY
- || theActionName == "TRANSPARENCY_CMD"
-#endif
- ) {
+ theActionName == "DEFLECTION_CMD" ||
+ theActionName == "TRANSPARENCY_CMD") {
QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
std::set<std::string> aTypes;
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);
}
//**************************************************************
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
if (aResult.get()) {
- XGUI_CustomPrs::getResultColor(aResult, aColor);
+ ModelAPI_Tools::getColor(aResult, aColor);
}
else {
// TODO: remove the obtaining a color from the AIS object
foreach(ObjectPtr anObj, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
if (aResult.get() != NULL) {
- ResultCompSolidPtr aCompsolidResult =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
- if (aCompsolidResult.get() != NULL) { // change colors for all sub-solids
- for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
- setColor(aCompsolidResult->subResult(i), !isRandomColor ? aColorResult :
- aDlg->getRandomColor());
+ ResultBodyPtr aBodyResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResult);
+ if (aBodyResult.get() != NULL) { // change colors 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++) {
+ setColor(*aRes, !isRandomColor ? aColorResult : aDlg->getRandomColor());
}
}
setColor(aResult, !isRandomColor ? aColorResult : aDlg->getRandomColor());
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);
}
//**************************************************************
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);
}
//**************************************************************
foreach(ObjectPtr anObj, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
if (aResult.get() != NULL) {
- ResultCompSolidPtr aCompsolidResult =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
- if (aCompsolidResult.get() != NULL) { // change property for all sub-solids
- for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
- setTransparency(aCompsolidResult->subResult(i), theTransparency);
+ ResultBodyPtr aBodyResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResult);
+ 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);
}
}
setTransparency(aResult, theTransparency);
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);
}
else {
// TODO: remove the obtaining a property from the AIS object
foreach(ObjectPtr anObj, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
if (aResult.get() != NULL) {
- ResultCompSolidPtr aCompsolidResult =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
- if (aCompsolidResult.get() != NULL) { // change property for all sub-solids
- for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
- setDeflection(aCompsolidResult->subResult(i), aDeflection);
+ ResultBodyPtr aBodyResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResult);
+ 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++) {
+ setDeflection(*aRes, aDeflection);
}
}
setDeflection(aResult, aDeflection);
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
if (aResult.get()) {
- aCurrentValue = XGUI_CustomPrs::getResultTransparency(aResult);
- }
- else {
- // TODO: remove the obtaining a property from the AIS object
- // this does not happen never because:
- // 1. The property 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()) {
- aCurrentValue = anAISObj->getDeflection();
- }
+ aCurrentValue = ModelAPI_Tools::getTransparency(aResult);
}
if (aCurrentValue > 0)
break;
return;
if (!abortAllOperations())
- return;
+ return;
// 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()));
- connect(aTransparencyWidget, SIGNAL(previewStateChanged()),
- this, SLOT(onPreviewStateChanged()));
aDlg->setContent(aTransparencyWidget);
aTransparencyWidget->setValue(aCurrentValue);
QString aDescription = contextMenuMgr()->action("TRANSPARENCY_CMD")->text();
aMgr->startOperation(aDescription.toStdString());
- aDlg->move(QCursor::pos());
- bool isDone = aDlg->exec() == QDialog::Accepted;
- if (!isDone)
- return;
-
- // 4. set the value to all results
- aCurrentValue = aTransparencyWidget->getValue();
- setTransparency(aCurrentValue, theObjects);
+ 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));
+ }
- aMgr->finishOperation();
updateCommandStatus();
}
void XGUI_Workshop::onTransparencyValueChanged()
{
XGUI_TransparencyWidget* aTransparencyWidget = (XGUI_TransparencyWidget*)sender();
- if (!aTransparencyWidget || !aTransparencyWidget->isPreviewNeeded())
+ if (!aTransparencyWidget)
return;
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
}
-//**************************************************************
-void XGUI_Workshop::onPreviewStateChanged()
-{
- XGUI_TransparencyWidget* aTransparencyWidget = (XGUI_TransparencyWidget*)sender();
- if (!aTransparencyWidget || !aTransparencyWidget->isPreviewNeeded())
- return;
-
- QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
- setTransparency(aTransparencyWidget->getValue(), anObjects);
- Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
-}
-
-//**************************************************************
-#define SET_DISPLAY_GROUP(aGroupName, aDisplay) \
-for (int i = 0; i < aDoc->size(aGroupName); i++) { \
- aDoc->object(aGroupName, i)->setDisplayed(aDisplay); \
-}
//******************************************************
void XGUI_Workshop::showObjects(const QObjectPtrList& theList, bool isVisible)
}
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
myObjectBrowser->updateAllIndexes();
+
+ updateColorScaleVisibility();
+ displayer()->updateViewer();
}
//**************************************************************
void XGUI_Workshop::showOnlyObjects(const QObjectPtrList& theList)
{
+ QObjectPtrList aSrcList = theList;
// Hide all displayed objects
QObjectPtrList aList = myDisplayer->displayedObjects();
foreach (ObjectPtr aObj, aList) {
- if (module()->canEraseObject(aObj))
+ if ((!aSrcList.contains(aObj)) && (module()->canEraseObject(aObj)))
aObj->setDisplayed(false);
+ else
+ aSrcList.removeAll(aObj);
}
//Do not use eraseAll if you didn't send Redisplay event:
//all objects are erased from viewer, but considered as displayed in displayer
#endif
std::set<ObjectPtr> anObjects;
- foreach (ObjectPtr aObj, theList) {
+ foreach (ObjectPtr aObj, aSrcList) {
anObjects.insert(aObj);
}
return;
// Show only objects from the list
- foreach (ObjectPtr aObj, theList) {
+ foreach (ObjectPtr aObj, aSrcList) {
aObj->setDisplayed(true);
}
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
// Necessary for update icons in ObjectBrowser on Linux
myObjectBrowser->updateAllIndexes();
+ updateColorScaleVisibility();
+ displayer()->updateViewer();
+}
+
+
+//**************************************************************
+void XGUI_Workshop::updateColorScaleVisibility()
+{
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ viewer()->setColorScaleShown(false);
+ if (aObjects.size() == 1) {
+ FieldStepPtr aStep =
+ std::dynamic_pointer_cast<ModelAPI_ResultField::ModelAPI_FieldStep>(aObjects.first());
+ if (aStep.get() && myDisplayer->isVisible(aStep)) {
+ AISObjectPtr aAisPtr = myDisplayer->getAISObject(aStep);
+ Handle(AIS_InteractiveObject) aIO = aAisPtr->impl<Handle(AIS_InteractiveObject)>();
+ ModuleBase_IStepPrs* aPrs = dynamic_cast<ModuleBase_IStepPrs*>(aIO.get());
+ if (aPrs) {
+ ModelAPI_AttributeTables::ValueType aType = aPrs->dataType();
+ if ((aType == ModelAPI_AttributeTables::DOUBLE) ||
+ (aType == ModelAPI_AttributeTables::INTEGER) ||
+ (aType == ModelAPI_AttributeTables::BOOLEAN)) {
+ myViewerProxy->setupColorScale();
+ if (aType == ModelAPI_AttributeTables::BOOLEAN) {
+ myViewerProxy->setColorScaleIntervals(2);
+ myViewerProxy->setColorScaleRange(0., 1.);
+ }
+ else {
+ double aMin, aMax;
+ aPrs->dataRange(aMin, aMax);
+ myViewerProxy->setColorScaleRange(aMin, aMax);
+ }
+ myViewerProxy->setColorScaleTitle(aStep->name().c_str());
+ myViewerProxy->setColorScaleShown(true);
+ }
+ }
+ }
+ }
+}
+
+
+//**************************************************************
+void XGUI_Workshop::setNormalView(bool toInvert)
+{
+ QList<ModuleBase_ViewerPrsPtr> aPrsList =
+ mySelector->selection()->getSelected(ModuleBase_ISelection::Viewer);
+ GeomShapePtr aPlanarFace;
+ foreach(ModuleBase_ViewerPrsPtr aPrs, aPrsList) {
+ GeomShapePtr aShape = aPrs->shape();
+ if (aShape.get() && aShape->isPlanar()) {
+ aPlanarFace = aShape;
+ break;
+ }
+ }
+ if (aPlanarFace.get()) {
+ GeomFacePtr aFace(new GeomAPI_Face(aPlanarFace));
+ GeomPlanePtr aPlane = aFace->getPlane();
+ GeomDirPtr aNormal = aPlane->direction();
+ if (toInvert)
+ aNormal->reverse();
+ GeomPointPtr aPos = aPlane->location();
+
+ double aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
+ 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;
+ aBox.Update(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
+ aView->FitAll(aBox);
+ }
}
//**************************************************************
//**************************************************************
void XGUI_Workshop::setDisplayMode(const QObjectPtrList& theList, int theMode)
{
- foreach(ObjectPtr aObj, theList) {
- myDisplayer->setDisplayMode(aObj, (XGUI_Displayer::DisplayMode)theMode, false);
+ foreach(ObjectPtr anObj, theList) {
+ myDisplayer->setDisplayMode(anObj, (XGUI_Displayer::DisplayMode)theMode, false);
- ResultCompSolidPtr aCompsolidResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aObj);
- if (aCompsolidResult.get() != NULL) { // change colors for all sub-solids
- for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
- myDisplayer->setDisplayMode(aCompsolidResult->subResult(i),
- (XGUI_Displayer::DisplayMode)theMode, false);
+ ResultBodyPtr aBodyResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anObj);
+ if (aBodyResult.get() != NULL) { // change display mode 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++) {
+ myDisplayer->setDisplayMode(*aRes, (XGUI_Displayer::DisplayMode)theMode, false);
}
}
}
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;
- 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)
myDisplayer->updateViewer();
}
+
+void XGUI_Workshop::synchronizeResultTree(const ResultBodyPtr& theRes, bool theUpdateViewer)
+{
+ if (theRes->numberOfSubs() > 0)
+ for (int i = 0; i < theRes->numberOfSubs(); i++) {
+ ResultBodyPtr aRes = theRes->subResult(i);
+ if (aRes.get())
+ synchronizeResultTree(aRes, theUpdateViewer);
+ }
+ else {
+ if (theRes->isDisplayed())
+ myDisplayer->display(theRes, theUpdateViewer);
+ else
+ myDisplayer->erase(theRes, theUpdateViewer);
+ }
+}
#endif
//******************************************************
{
FeaturePtr aFeature;
QObjectPtrList aSelList = theObjects;
+ QObjectPtrList aNewSel;
bool aHasHidden = false;
foreach(ObjectPtr aObj, theObjects) {
aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
for(aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
aHasHidden |= (*aIt)->isConcealed();
aSelList.append(*aIt);
+ aNewSel.append(*aIt);
}
}
}
if (aSelList.count() > theObjects.count()) {
// if something was found
- bool aBlocked = objectBrowser()->blockSignals(true);
objectBrowser()->setObjectsSelected(aSelList);
- objectBrowser()->blockSignals(aBlocked);
+ objectBrowser()->ensureVisible(aNewSel.first());
}
if (aHasHidden)
QMessageBox::information(desktop(), tr("Find results"),
{
ResultPtr aResult;
QObjectPtrList aSelList = theObjects;
+ QObjectPtrList aNewSel;
FeaturePtr aFeature;
foreach(ObjectPtr aObj, theObjects) {
aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
aFeature = ModelAPI_Feature::feature(aResult);
if (aFeature.get()) {
aSelList.append(aFeature);
+ aNewSel.append(aFeature);
}
}
}
if (aSelList.count() > theObjects.count()) {
// if something was found
- bool aBlocked = objectBrowser()->blockSignals(true);
objectBrowser()->setObjectsSelected(aSelList);
- objectBrowser()->blockSignals(aBlocked);
+ objectBrowser()->ensureVisible(aNewSel.first());
}
}
aMgr->startOperation(aDescription.toStdString());
aDoc->addFolder(aFeature);
aMgr->finishOperation();
+
+ updateCommandStatus();
}
QString aDescription = contextMenuMgr()->action(
isBefore ? "ADD_TO_FOLDER_BEFORE_CMD" : "ADD_TO_FOLDER_AFTER_CMD")->text();
+ QMap<ObjectPtr, bool> aStates = myObjectBrowser->getFoldersState(aDoc);
+
aMgr->startOperation(aDescription.toStdString());
aDoc->moveToFolder(aFeatures, aFolder);
aMgr->finishOperation();
+
+ myObjectBrowser->setFoldersState(aStates);
+
+ updateCommandStatus();
}
void XGUI_Workshop::moveOutFolder(bool isBefore)
SessionPtr aMgr = ModelAPI_Session::get();
DocumentPtr aDoc = aMgr->activeDocument();
-
QString aDescription = contextMenuMgr()->action(
isBefore ? "ADD_OUT_FOLDER_BEFORE_CMD" : "ADD_OUT_FOLDER_AFTER_CMD")->text();
+ QMap<ObjectPtr, bool> aStates = myObjectBrowser->getFoldersState(aDoc);
+
aMgr->startOperation(aDescription.toStdString());
aDoc->removeFromFolder(aFeatures, isBefore);
aMgr->finishOperation();
+
+ myObjectBrowser->setFoldersState(aStates);
+
+ updateCommandStatus();
+}
+
+void XGUI_Workshop::onAutoApply()
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ bool isBlocked = aMgr->isAutoUpdateBlocked();
+ aMgr->blockAutoUpdate(!isBlocked);
+}
+
+void XGUI_Workshop::updateAutoComputeState()
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ bool isComputeBlocked = aMgr->isAutoUpdateBlocked();
+#ifdef HAVE_SALOME
+// QAction* aUpdateCmd;
+// QList<QAction*> aCommands = mySalomeConnector->commandList();
+// foreach(QAction* aCmd, aCommands) {
+// if (aCmd->data().toString() == "AUTOCOMPUTE_CMD") {
+// aUpdateCmd = aCmd;
+// break;
+// }
+// }
+// aUpdateCmd->setIcon(isComputeBlocked? QIcon(":pictures/autoapply_stop.png") :
+// QIcon(":pictures/autoapply_start.png"));
+#else
+ AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
+ AppElements_Command* aUpdateCmd = aMenuBar->feature("AUTOCOMPUTE_CMD");
+ aUpdateCmd->button()->setIcon(isComputeBlocked? QIcon(":pictures/autoapply_stop.png") :
+ QIcon(":pictures/autoapply_start.png"));
+#endif
+}
+
+
+void XGUI_Workshop::clearTemporaryDir()
+{
+ QDir aDir(myTmpDir.path());
+ if (!aDir.isEmpty()) {
+ QStringList aEntries;
+ aDir.entryList(aEntries);
+ foreach(QString aFile, aEntries) {
+ aDir.remove(aFile);
+ }
+ }
+}
+
+
+void XGUI_Workshop::onDockSizeChanged()
+{
+ QDockWidget* aDockWgt = dynamic_cast<QDockWidget*>(myObjectBrowser->parentWidget());
+ int aObWidth = aDockWgt->size().width();
+ if (myPropertyPanel->width() != aObWidth) {
+ QList<QDockWidget*> aWgtList;
+ aWgtList << myPropertyPanel << aDockWgt;
+ QList<int> aSizeList;
+ aSizeList << aObWidth << aObWidth;
+ desktop()->resizeDocks(aWgtList, aSizeList, Qt::Horizontal);
+ disconnect(myObjectBrowser, SIGNAL(sizeChanged()), this, SLOT(onDockSizeChanged()));
+ }
+}
+
+void XGUI_Workshop::deactivateCurrentSelector()
+{
+ myActiveControlMgr->deactivateSelector(myActiveControlMgr->activeSelector());
}
