-// Copyright (C) 2014-20xx 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
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
-//#include "XGUI_Constants.h"
#include "XGUI_Workshop.h"
#include "XGUI_ActionsMgr.h"
+#include "XGUI_ActiveControlMgr.h"
+#include "XGUI_ActiveControlSelector.h"
#include "XGUI_MenuMgr.h"
#include "XGUI_ColorDialog.h"
#include "XGUI_DeflectionDialog.h"
+#include "XGUI_TransparencyWidget.h"
#include "XGUI_ContextMenuMgr.h"
#include "XGUI_Displayer.h"
#include "XGUI_ErrorDialog.h"
#include "XGUI_ErrorMgr.h"
+#include "XGUI_FacesPanel.h"
+#include "XGUI_FacesPanelSelector.h"
#include "XGUI_ModuleConnector.h"
#include "XGUI_ObjectsBrowser.h"
#include "XGUI_OperationMgr.h"
#include "XGUI_PropertyPanel.h"
+#include "XGUI_PropertyPanelSelector.h"
+#include "XGUI_PropertyDialog.h"
#include "XGUI_SalomeConnector.h"
#include "XGUI_Selection.h"
+#include "XGUI_SelectionActivate.h"
#include "XGUI_SelectionMgr.h"
#include "XGUI_Tools.h"
#include "XGUI_ViewerProxy.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 <AppElements_Workbench.h>
#endif
+#include <Config_XMLReader.h>
+
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_ResultField.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
-#include <ModelAPI_ResultCompSolid.h>
#include <ModelAPI_Tools.h>
//#include <PartSetPlugin_Part.h>
#include <ModuleBase_WidgetValidated.h>
#include <ModuleBase_ModelWidget.h>
#include <ModuleBase_ResultPrs.h>
+#include <ModuleBase_ActionIntParameter.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <QToolButton>
#include <QAction>
#include <QDesktopWidget>
+#include <QProcess>
+#include <QDesktopServices>
#include <iterator>
#ifdef TINSPECTOR
#include <CDF_Session.hxx>
#include <CDF_Application.hxx>
-#include <TInspector_Communicator.hxx>
-#include <VInspector_CallBack.hxx>
+#include <inspector/TInspector_Communicator.hxx>
+#include <inspector/VInspector_CallBack.hxx>
static TInspector_Communicator* MyTCommunicator;
static Handle(VInspector_CallBack) MyVCallBack;
#include <dlfcn.h>
#endif
+//#define DEBUG_WITH_MESSAGE_REPORT
+
QString XGUI_Workshop::MOVE_TO_END_COMMAND = QObject::tr("Move to the end");
//#define DEBUG_DELETE
//#define DEBUG_FEATURE_NAME
//#define DEBUG_CLEAN_HISTORY
+#ifdef HAVE_SALOME
+static QString MyFilter(QObject::tr("SHAPER files (*.shaper *.opp)"));
+static QString MyFilter2(QObject::tr("SHAPER files (*.shaper)"));
+static QString MyExtension(".shaper");
+#else
+static QString MyFilter(QObject::tr("OpenParts files (*.opp);;All files (*.*)"));
+static QString MyFilter2(QObject::tr("OpenParts files (*.opp)"));
+static QString MyExtension(".opp");
+#endif
+
+
+//******************************************************
XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
: QObject(),
- myCurrentDir(QString()),
myModule(NULL),
mySalomeConnector(theConnector),
myPropertyPanel(0),
+ myInspectionPanel(0),
+ myFacesPanel(0),
myObjectBrowser(0),
myDisplayer(0)
//myViewerSelMode(TopAbs_FACE)
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(mySelector, SIGNAL(selectionChanged()), this, SLOT(updateCommandStatus()));
myActionsMgr = new XGUI_ActionsMgr(this);
+ myActiveControlMgr = new XGUI_ActiveControlMgr(myModuleConnector);
myMenuMgr = new XGUI_MenuMgr(this);
myErrorDlg = new XGUI_ErrorDialog(QApplication::desktop());
myContextMenuMgr = new XGUI_ContextMenuMgr(this);
delete myDisplayer;
delete myDataModelXMLReader;
+ delete mySelectionActivate;
+ delete myMenuMgr;
+ clearTemporaryDir();
}
//******************************************************
Config_PropManager::registerProp("Plugins", "default_path", "Default Path",
Config_Prop::Directory, "");
+ std::string aDir = Config_XMLReader::resourcesConfigFile();
+ Config_PropManager::registerProp("Plugins", "import_initial_path", "Import initial directory",
+ Config_Prop::Directory, aDir);
+
+#ifdef _DEBUG
+ Config_PropManager::registerProp("Plugins", "create_part_by_start", "Create Part by Start",
+ Config_Prop::Boolean, "false");
+ Config_PropManager::registerProp("Plugins", "show_hide_faces", "Show Hide Faces (on the right)",
+ Config_Prop::Boolean, "false");
+#endif
registerValidators();
// Calling of loadCustomProps before activating module is required
SLOT(onTrihedronVisibilityChanged(bool)));
emit applicationStarted();
+
+#ifdef _DEBUG
+ bool aNewPart = Config_PropManager::boolean("Plugins", "create_part_by_start");
+ if (aNewPart) {
+ module()->launchOperation("Part", false); // PartSetPlugin_Part::ID()
+ }
+#endif
}
+//******************************************************
void XGUI_Workshop::activateModule()
{
- myModule->activateSelectionFilters();
+ selectionActivate()->updateSelectionFilters();
connect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
myOperationMgr->activate();
}
+//******************************************************
void XGUI_Workshop::deactivateModule()
{
- myModule->deactivateSelectionFilters();
-
// remove internal displayer filter
- displayer()->deactivateSelectionFilters();
+ displayer()->deactivateSelectionFilters(false);
disconnect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
XGUI_Displayer* aDisplayer = displayer();
QObjectPtrList aDisplayed = aDisplayer->displayedObjects();
aDisplayer->deactivateObjects(aDisplayed, true);
- Handle(AIS_InteractiveContext) aContext = viewer()->AISContext();
- Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(aDisplayer->getTrihedron());
- /// deactivate trihedron in selection modes
- TColStd_ListOfInteger aTColModes;
- aContext->ActivatedModes(aTrihedron, aTColModes);
- TColStd_ListIteratorOfListOfInteger itr( aTColModes );
- for (; itr.More(); itr.Next() ) {
- Standard_Integer aMode = itr.Value();
- aContext->Deactivate(aTrihedron, aMode);
- }
+ selectionActivate()->deactivateTrihedronInSelectionModes();
+
#ifdef BEFORE_TRIHEDRON_PATCH
+ //Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(aDisplayer->getTrihedron());
/// Trihedron problem: objects stayed in the viewer, should be removed manually
/// otherwise in SALOME happens crash by HideAll in the viewer
aContext->Remove(aTrihedron->Position(), true);
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)));
addHistoryMenu(aAction, SIGNAL(updateRedoHistory(const QList<ActionInfo>&)), SLOT(onRedo(int)));
salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
- //aAction = salomeConnector()->addDesktopCommand("REBUILD_CMD", tr("Rebuild"),
- // tr("Rebuild data objects"),
- // QIcon(":pictures/rebuild.png"), QKeySequence(),
+
+ //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(onRebuild()));
- //salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
+ //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(),
SIGNAL(updateRedoHistory(const QList<ActionInfo>&)),
SLOT(onRedo(int)));
- //aCommand = aGroup->addFeature("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
- // QIcon(":pictures/rebuild.png"), QKeySequence());
- //aCommand->connectTo(this, SLOT(onRebuild()));
-
- //aCommand->disable();
-
aCommand = aGroup->addFeature("OPEN_CMD", tr("Open..."), tr("Open a new document"),
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()));
}
#ifndef HAVE_SALOME
+//******************************************************
AppElements_Workbench* XGUI_Workshop::addWorkbench(const QString& theName)
{
AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
(anOperationMgr->currentOperation());
if (aFOperation) {
//if (errorMgr()->canProcessClick(anAction, aFOperation->feature()))
- myOperationMgr->onCommitOperation();
+ 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*>
+ (anOperationMgr->currentOperation());
+ if (aFOperation) {
+ if (myOperationMgr->commitOperation())
+ module()->launchOperation(aFOperation->id(), false);
}
}
}
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("OPENPARTS_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 (!myModule->canActivateSelection(theObject)) {
- if (myDisplayer->isActive(theObject)) {
+ if (selectionActivate()->isActive(theObject)) {
QObjectPtrList anObjects;
anObjects.append(theObject);
myDisplayer->deactivateObjects(anObjects, theUpdateViewer);
return aHasNested;
}
+//******************************************************
void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
{
ModuleBase_OperationFeature* aFOperation =
if (!aFOperation)
return;
- showPropertyPanel();
+ showPanel(myPropertyPanel);
myPropertyPanel->cleanContent();
QList<ModuleBase_ModelWidget*> aWidgets;
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
aWidget->restoreValue();
aWidget->enableFocusProcessing();
}
- ModuleBase_Tools::flushUpdated(aFeature);
-
// update visible state of Preview button
std::shared_ptr<Config_FeatureMessage> aFeatureInfo;
#ifdef HAVE_SALOME
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());
new Events_Message(Events_Loop::eventByName(EVENT_PREVIEW_BLOCKED)));
Events_Loop::loop()->send(aMsg);
}
+ // if update happens after preview is blocked, it does nothing when blocked
+ // it improves performance for valid objects on feature start
+ ModuleBase_Tools::flushUpdated(aFeature);
+
myPropertyPanel->setModelWidgets(aWidgets);
aFOperation->setPropertyPanel(myPropertyPanel);
myErrorMgr->setPropertyPanel(myPropertyPanel);
}
+//******************************************************
void XGUI_Workshop::connectToPropertyPanel(const bool isToConnect)
{
XGUI_PropertyPanel* aPropertyPanel = propertyPanel();
myModule->operationResumed(theOperation);
}
-
//******************************************************
void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
{
ModuleBase_ISelection* aSel = mySelector->selection();
QObjectPtrList aObj = aSel->selectedPresentations();
//!< No need for property panel
- hidePropertyPanel();
+ hidePanel(myPropertyPanel);
myPropertyPanel->cleanContent();
connectToPropertyPanel(false);
QObjectPtrList anObjects;
FeaturePtr aFeature = aFOperation->feature();
if (aFeature.get()) { // feature may be not created (plugin load fail)
- if (myDisplayer->isVisible(aFeature) && !myDisplayer->isActive(aFeature))
+ if (myDisplayer->isVisible(aFeature) && !selectionActivate()->isActive(aFeature))
anObjects.append(aFeature);
std::list<ResultPtr> aResults;
ModelAPI_Tools::allResults(aFeature, aResults);
std::list<ResultPtr>::const_iterator aIt;
for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
ResultPtr anObject = *aIt;
- if (myDisplayer->isVisible(anObject) && !myDisplayer->isActive(anObject)) {
+ if (myDisplayer->isVisible(anObject) && !selectionActivate()->isActive(anObject)) {
anObjects.append(anObject);
}
}
activateObjectsSelection(anObjects);
}
-
+//******************************************************
void XGUI_Workshop::onOperationCommitted(ModuleBase_Operation* theOperation)
{
myModule->operationCommitted(theOperation);
}
+//******************************************************
void XGUI_Workshop::onOperationAborted(ModuleBase_Operation* theOperation)
{
myModule->operationAborted(theOperation);
}
+//******************************************************
void XGUI_Workshop::setGrantedFeatures(ModuleBase_Operation* theOperation)
{
ModuleBase_OperationFeature* aFOperation =
} 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);
+ QString aFile = QFileDialog::getOpenFileName(desktop(), tr("Open file"), QString(), MyFilter);
+ 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
+ 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);
+ if (aPart.get())
+ aPart->activate();
+ }
+ }
#endif
+
QApplication::restoreOverrideCursor();
}
//******************************************************
bool XGUI_Workshop::onSave()
{
- if(!abortAllOperations())
+ 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;
}
//******************************************************
bool XGUI_Workshop::onSaveAs()
{
- if(!abortAllOperations())
- 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()) {
+ if(!myOperationMgr->abortAllOperations(XGUI_OperationMgr::XGUI_InformationMessage))
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;
+ myCurrentFile = QFileDialog::getSaveFileName(desktop(), tr("Select name to save file..."),
+ QString(), MyFilter2);
+ 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)
{
- objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
- SessionPtr aMgr = ModelAPI_Session::get();
- std::list<std::string> aUndoList = aMgr->undoList();
- if (aMgr->isOperation()) {
- /// this is important for nested operations
- /// when sketch operation is active, this condition is false and
- /// the sketch operation is not aborted
- operationMgr()->onAbortOperation();
- }
- std::list<std::string>::const_iterator aIt = aUndoList.cbegin();
- for (int i = 0; (i < theTimes) && (aIt != aUndoList.cend()); ++i, ++aIt) {
- aMgr->undo();
- if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
- myObjectBrowser->rebuildDataTree();
- }
-
- operationMgr()->updateApplyOfOperations();
- updateCommandStatus();
+ processUndoRedo(ActionUndo, theTimes);
+ myObjectBrowser->updateAllIndexes(1);
}
//******************************************************
void XGUI_Workshop::onRedo(int theTimes)
{
+ processUndoRedo(ActionRedo, theTimes);
+ myObjectBrowser->updateAllIndexes(1);
+}
+
+//******************************************************
+void XGUI_Workshop::processUndoRedo(const ModuleBase_ActionType theActionType, int theTimes)
+{
+ ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+ if (anActiveWidget) {
+ ActionIntParamPtr aParam(new ModuleBase_ActionIntParameter(theTimes));
+ if (anActiveWidget->processAction(theActionType, aParam))
+ 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);
- objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
SessionPtr aMgr = ModelAPI_Session::get();
- std::list<std::string> aRedoList = aMgr->redoList();
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
- operationMgr()->onAbortOperation();
+ if (aOpMgr->canStopOperation(aOpMgr->currentOperation()))
+ aOpMgr->abortOperation(aOpMgr->currentOperation());
+ else
+ {
+ myDisplayer->enableUpdateViewer(isUpdateEnabled);
+ return;
+ }
}
- std::list<std::string>::const_iterator aIt = aRedoList.cbegin();
- for (int i = 0; (i < theTimes) && (aIt != aRedoList.cend()); ++i, ++aIt) {
- aMgr->redo();
+ objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
+ 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) {
+ if (theActionType == ActionUndo)
+ aMgr->undo();
+ else
+ aMgr->redo();
+
if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
myObjectBrowser->rebuildDataTree();
}
operationMgr()->updateApplyOfOperations();
+ facesPanel()->reset(true);
updateCommandStatus();
// unblock the viewer update functionality and make update on purpose
myDisplayer->enableUpdateViewer(isUpdateEnabled);
myDisplayer->updateViewer();
+ // Clear messages in status bar from previous operations if exists
+ setStatusBarMessage("");
}
-//******************************************************
-//void XGUI_Workshop::onRebuild()
-//{
-// SessionPtr aMgr = ModelAPI_Session::get();
-// bool aWasOperation = aMgr->isOperation(); // keep this value
-// if (!aWasOperation) {
-// aMgr->startOperation("Rebuild");
-// }
-// static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
-// Events_Loop::loop()->send(std::shared_ptr<Events_Message>(
-// new Events_Message(aRebuildEvent, this)));
-// if (!aWasOperation) {
-// aMgr->finishOperation();
-// }
-// updateCommandStatus();
-//}
-
//******************************************************
void XGUI_Workshop::onWidgetStateChanged(int thePreviousState)
{
- ModuleBase_ModelWidget* anActiveWidget = 0;
- ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
- if (anOperation) {
- ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
- if (aPanel)
- anActiveWidget = aPanel->activeWidget();
- }
+ ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+ //ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
+ //if (anOperation) {
+ // ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
+ // if (aPanel)
+ // anActiveWidget = aPanel->activeWidget();
+ //}
if (anActiveWidget)
operationMgr()->onValidateOperation();
}
}
+//******************************************************
void XGUI_Workshop::onWidgetObjectUpdated()
{
operationMgr()->onValidateOperation();
}
+//******************************************************
ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
{
QString libName = QString::fromStdString(library(theModule.toStdString()));
CREATE_FUNC crtInst = 0;
#ifdef WIN32
- HINSTANCE modLib = ::LoadLibrary((LPTSTR) qPrintable(libName));
+ HINSTANCE modLib = ::LoadLibraryA(qPrintable(libName));
if (!modLib) {
LPVOID lpMsgBuf;
::FormatMessage(
if (aMgr->hasModuleDocument()) {
foreach(QAction* aCmd, aCommands) {
QString aId = aCmd->data().toString();
- if (aId == "UNDO_CMD")
- aCmd->setEnabled(myModule->canUndo());
- else if (aId == "REDO_CMD")
- aCmd->setEnabled(myModule->canRedo());
+ if (aId == "UNDO_CMD") {
+ bool isActionEnabled = false;
+ // if ultimate is true -> using result of operation only, or using OR combination
+ ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+ if (anActiveWidget && anActiveWidget->canProcessAction(ActionUndo, isActionEnabled))
+ aCmd->setEnabled(isActionEnabled);
+ else
+ aCmd->setEnabled(myModule->canUndo());
+ }
+ else if (aId == "REDO_CMD") {
+ bool isActionEnabled = false;
+ // if ultimate is true -> using result of operation only, or using OR combination
+ ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+ if (anActiveWidget && anActiveWidget->canProcessAction(ActionRedo, isActionEnabled))
+ aCmd->setEnabled(isActionEnabled);
+ 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);
emit commandStatusUpdated();
}
+//******************************************************
void XGUI_Workshop::updateHistory()
{
- std::list<std::string> aUndoList = ModelAPI_Session::get()->undoList();
- QList<ActionInfo> aUndoRes = processHistoryList(aUndoList);
- emit updateUndoHistory(aUndoRes);
+ bool isActionEnabled = false;
+ ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+ QList<ActionInfo> aUndoRes;
+ QList<ActionInfo> aRedoRes;
+ if (anActiveWidget && anActiveWidget->canProcessAction(ActionUndo, isActionEnabled)) {
+ aUndoRes = anActiveWidget->actionsList(ActionUndo);
+ aRedoRes = anActiveWidget->actionsList(ActionRedo);
+ } else {
+ std::list<std::string> aUndoList = ModelAPI_Session::get()->undoList();
+ aUndoRes = processHistoryList(aUndoList);
- std::list<std::string> aRedoList = ModelAPI_Session::get()->redoList();
- QList<ActionInfo> aRedoRes = processHistoryList(aRedoList);
+ std::list<std::string> aRedoList = ModelAPI_Session::get()->redoList();
+ aRedoRes = processHistoryList(aRedoList);
+ }
+ emit updateUndoHistory(aUndoRes);
emit updateRedoHistory(aRedoRes);
}
aObjDock->setWindowTitle(tr("Object browser"));
aObjDock->setStyleSheet(
"::title { position: relative; padding-left: 5px; text-align: left center }");
- myObjectBrowser = new XGUI_ObjectsBrowser(aObjDock);
- myObjectBrowser->setXMLReader(myDataModelXMLReader);
+ myObjectBrowser = new XGUI_ObjectsBrowser(aObjDock, this);
+ myObjectBrowser->initialize(myModule->rootNode());
myModule->customizeObjectBrowser(myObjectBrowser);
aObjDock->setWidget(myObjectBrowser);
QDockWidget* aObjDock = createObjectBrowser(aDesktop);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
myPropertyPanel = new XGUI_PropertyPanel(aDesktop, myOperationMgr);
+ myActiveControlMgr->addSelector(new XGUI_PropertyPanelSelector(myPropertyPanel));
+
myPropertyPanel->setupActions(myActionsMgr);
myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea |
Qt::BottomDockWidgetArea);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
- hidePropertyPanel(); ///<! Invisible by default
+ hidePanel(myPropertyPanel); ///<! Invisible by default
+
+ myFacesPanel = new XGUI_FacesPanel(aDesktop, myModuleConnector);
+ 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->setAllowedAreas(Qt::LeftDockWidgetArea |
+ Qt::RightDockWidgetArea);
+ aDesktop->addDockWidget(Qt::RightDockWidgetArea, myInspectionPanel);
+
+ myInspectionPanel->hide();
+
+ aDesktop->addDockWidget(
+#ifdef HAVE_SALOME
+ Qt::RightDockWidgetArea,
+#else
+ Qt::LeftDockWidgetArea,
+#endif
+ myFacesPanel);
+ hidePanel(myFacesPanel); ///<! Invisible by default
+
+#ifdef _DEBUG
+ bool aShowOnTheRight = Config_PropManager::boolean("Plugins", "show_hide_faces");
+ if (aShowOnTheRight) {
+ aDesktop->addDockWidget(Qt::RightDockWidgetArea, myFacesPanel);
+ showPanel(myFacesPanel);
+ }
+#endif
hideObjectBrowser();
+
+#ifndef HAVE_SALOME
+#ifdef _DEBUG
+ if (!aShowOnTheRight)
+ {
+#endif // _DEBUG
+ aDesktop->tabifyDockWidget(myFacesPanel, aObjDock);
+#ifdef _DEBUG
+ }
+#endif // _DEBUG
+
+#endif // HAVE_SALOME
+
aDesktop->tabifyDockWidget(aObjDock, myPropertyPanel);
myPropertyPanel->installEventFilter(myOperationMgr);
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*)),
}
//******************************************************
-void XGUI_Workshop::showPropertyPanel()
+void XGUI_Workshop::showPanel(QDockWidget* theDockWidget)
{
- QAction* aViewAct = myPropertyPanel->toggleViewAction();
- ///<! Restore ability to close panel from the window's menu
- aViewAct->setEnabled(true);
- myPropertyPanel->show();
- myPropertyPanel->raise();
+ if (theDockWidget == myPropertyPanel) {
+ QAction* aViewAct = myPropertyPanel->toggleViewAction();
+ ///<! Restore ability to close panel from the window's menu
+ aViewAct->setEnabled(true);
+ }
+ theDockWidget->show();
+ theDockWidget->raise();
// The next code is necessary to made the property panel the active window
// 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::activateWindow(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
- ModuleBase_Tools::setFocus(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
+ ModuleBase_Tools::setFocus(theDockWidget, "XGUI_Workshop::showPanel()");
}
//******************************************************
-void XGUI_Workshop::hidePropertyPanel()
+void XGUI_Workshop::hidePanel(QDockWidget* theDockWidget)
{
- QAction* aViewAct = myPropertyPanel->toggleViewAction();
- ///<! Do not allow to show empty property panel
- aViewAct->setEnabled(false);
- myPropertyPanel->hide();
+ if (theDockWidget && theDockWidget == myPropertyPanel) {
+ QAction* aViewAct = theDockWidget->toggleViewAction();
+ ///<! Do not allow to show empty property panel
+ aViewAct->setEnabled(false);
+ }
+ theDockWidget->hide();
// the property panel is active window of the desktop, when it is
// hidden, it is undefined which window becomes active. By this reason
// are processed by this console. For example Undo actions.
// It is possible that this code is to be moved to SHAPER package
QMainWindow* aDesktop = desktop();
- ModuleBase_Tools::activateWindow(aDesktop, "XGUI_Workshop::hidePropertyPanel()");
- ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::showPropertyPanel()");
+ ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::hidePanel()");
}
//******************************************************
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);
viewer()->eraseAll();
#endif
updateCommandStatus();
+ // Necessary for update icons in ObjectBrowser on Linux
+ myObjectBrowser->updateAllIndexes();
} else if (theId == "SELECT_VERTEX_CMD") {
setViewerSelectionMode(TopAbs_VERTEX);
} else if (theId == "SELECT_EDGE_CMD") {
setViewerSelectionMode(TopAbs_EDGE);
} else if (theId == "SELECT_FACE_CMD") {
setViewerSelectionMode(TopAbs_FACE);
+ } else if (theId == "INSERT_FOLDER_CMD") {
+ insertFeatureFolder();
+ } else if (theId == "ADD_TO_FOLDER_BEFORE_CMD") {
+ insertToFolder(true);
+ } else if (theId == "ADD_TO_FOLDER_AFTER_CMD") {
+ insertToFolder(false);
+ } else if (theId == "ADD_OUT_FOLDER_BEFORE_CMD") {
+ moveOutFolder(true);
+ } else if (theId == "ADD_OUT_FOLDER_AFTER_CMD") {
+ moveOutFolder(false);
} else if (theId == "SELECT_RESULT_CMD") {
//setViewerSelectionMode(-1);
//IMP: an attempt to use result selection with other selection modes
if (!aContext.IsNull())
aParameters.Append(aContext);
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+ Handle(Message_Report) aContextReport = aContext->GetReport();
+ aContext->SetReportActive (Standard_True);
+ aContextReport->SetLimit (1000);
+ if (!aContextReport.IsNull())
+ aParameters.Append(aContextReport);
+#endif
MyVCallBack = new VInspector_CallBack();
myDisplayer->setCallBack(MyVCallBack);
#ifndef HAVE_SALOME
#endif
aParameters.Append(MyVCallBack);
- MyTCommunicator->registerPlugin("SMBrowser"); // custom plugin to view ModelAPI
+ MyTCommunicator->RegisterPlugin("TKDFBrowser");
+ MyTCommunicator->RegisterPlugin("TKShapeView");
+ MyTCommunicator->RegisterPlugin("TKVInspector");
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+ MyTCommunicator->RegisterPlugin("TKMessageView");
+#endif
+ //MyTCommunicator->RegisterPlugin("SMBrowser"); // custom plugin to view ModelAPI
+ //MyTCommunicator->RegisterPlugin("TKSMBrowser"); // custom plugin to view ModelAPI
- MyTCommunicator->init(aParameters);
- MyTCommunicator->Activate("SMBrowser"); // to have button in TInspector
+ MyTCommunicator->Init(aParameters);
+ MyTCommunicator->Activate("TKSMBrowser"); // to have button in TInspector
+#ifndef DEBUG_WITH_MESSAGE_REPORT
MyTCommunicator->Activate("TKVInspector"); // to have filled callback by model
+#endif
MyTCommunicator->Activate("TKDFBrowser");
+
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+ MyTCommunicator->Activate("TKMessageView"); // temporary
+ MyTCommunicator->Activate("TKVInspector"); // to have filled callback by model
+#endif
}
- MyTCommunicator->setVisible(true);
+ MyTCommunicator->SetVisible(true);
}
}
#endif
else
myViewerSelMode.append(theMode);
}
- activateObjectsSelection(myDisplayer->displayedObjects());
+ selectionActivate()->updateSelectionModes();
}
//**************************************************************
module()->activeSelectionModes(aModes);
if (aModes.isEmpty() && (myViewerSelMode.length() > 0))
aModes.append(myViewerSelMode);
- myDisplayer->activateObjects(aModes, theList);
+ selectionActivate()->activateObjects(aModes, theList);
+}
+
+//**************************************************************
+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;
+ ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anObject);
+ if (aCompRes.get()) {
+ std::list<ResultPtr> allRes;
+ ModelAPI_Tools::allSubs(aCompRes, allRes);
+ if (allRes.empty()) {
+ anAllProcessedObjects.insert(anObject);
+ } 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
+ anAllProcessedObjects.insert(anObject);
+ }
+
+ // find hidden objects in faces panel
+ std::set<ObjectPtr> aHiddenObjects;
+ QStringList aHiddenObjectNames;
+ for (std::set<ObjectPtr>::const_iterator anObjectsIt = anAllProcessedObjects.begin();
+ anObjectsIt != anAllProcessedObjects.end(); anObjectsIt++) {
+ if (!facesPanel()->isObjectHiddenByPanel(*anObjectsIt))
+ continue;
+ aHiddenObjects.insert(*anObjectsIt);
+ aHiddenObjectNames.append((*anObjectsIt)->data()->name().c_str());
+ }
+ 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);
+
+ bool aToBeDisplayed = anAnswer == QMessageBox::Yes;
+ if (aToBeDisplayed)
+ facesPanel()->restoreObjects(aHiddenObjects);
+
+ return aToBeDisplayed;
}
//**************************************************************
bool hasParameter = false;
bool hasCompositeOwner = false;
bool hasResultInHistory = false;
+ bool hasFolder = false;
ModuleBase_Tools::checkObjects(anObjects, hasResult, hasFeature, hasParameter, hasCompositeOwner,
- hasResultInHistory);
- if (!(hasFeature || hasParameter))
+ hasResultInHistory, hasFolder);
+ if (!(hasFeature || hasParameter || hasFolder))
return;
// delete objects
ModuleBase_Tools::convertToFeatures(anObjects, aFeatures);
ModelAPI_Tools::findAllReferences(aFeatures, aReferences);
+ std::set<FolderPtr> aFolders;
+ ModuleBase_Tools::convertToFolders(anObjects, aFolders);
+
bool aDone = false;
QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text() + " %1";
aDescription = aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
aFeatures.insert(aFeatureRefsToDelete.begin(), aFeatureRefsToDelete.end());
aDone = ModelAPI_Tools::removeFeatures(aFeatures, false);
}
+ if (aFolders.size() > 0) {
+ std::set<FolderPtr>::const_iterator anIt = aFolders.begin(),
+ aLast = aFolders.end();
+ for (; anIt != aLast; anIt++) {
+ FolderPtr aFolder = *anIt;
+ if (aFolder.get()) {
+ DocumentPtr aDoc = aFolder->document();
+ aDoc->removeFolder(aFolder);
+ }
+ }
+ }
+
if (aDone)
operationMgr()->commitOperation();
else
//**************************************************************
bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theObjects)
{
- std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
std::set<FeaturePtr> aFeatures;
ModuleBase_Tools::convertToFeatures(theObjects, aFeatures);
return ModelAPI_Tools::removeFeaturesAndReferences(aFeatures);
}
+//******************************************************
bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes)
{
bool isFoundResultType = false;
return std::list<FeaturePtr>(aObjectIt, aCurrentIt);
}
+//******************************************************
bool XGUI_Workshop::canMoveFeature()
{
QString anActionId = "MOVE_CMD";
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::canChangeColor() const
+bool XGUI_Workshop::canChangeProperty(const QString& theActionName) const
{
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ if (theActionName == "COLOR_CMD" ||
+ theActionName == "DEFLECTION_CMD"
+#ifdef USE_TRANSPARENCY
+ || theActionName == "TRANSPARENCY_CMD"
+#endif
+ ) {
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
- std::set<std::string> aTypes;
- aTypes.insert(ModelAPI_ResultGroup::group());
- aTypes.insert(ModelAPI_ResultConstruction::group());
- aTypes.insert(ModelAPI_ResultBody::group());
- aTypes.insert(ModelAPI_ResultPart::group());
+ std::set<std::string> aTypes;
+ aTypes.insert(ModelAPI_ResultGroup::group());
+ aTypes.insert(ModelAPI_ResultConstruction::group());
+ aTypes.insert(ModelAPI_ResultBody::group());
+ aTypes.insert(ModelAPI_ResultPart::group());
- return hasResults(aObjects, aTypes);
+ return hasResults(aObjects, aTypes);
+ }
+ return false;
}
+//******************************************************
void setColor(ResultPtr theResult, const std::vector<int>& theColor)
{
if (!theResult.get())
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 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());
}
//**************************************************************
-bool XGUI_Workshop::canChangeDeflection() const
-{
- QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
-
- std::set<std::string> aTypes;
- aTypes.insert(ModelAPI_ResultGroup::group());
- aTypes.insert(ModelAPI_ResultConstruction::group());
- aTypes.insert(ModelAPI_ResultBody::group());
- aTypes.insert(ModelAPI_ResultPart::group());
-
- return hasResults(aObjects, aTypes);
-}
-
void setDeflection(ResultPtr theResult, const double theDeflection)
{
if (!theResult.get())
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);
+}
+
+//**************************************************************
+void setTransparency(ResultPtr theResult, double theTransparency)
+{
+ if (!theResult.get())
+ return;
+
+ 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);
}
+//**************************************************************
+void setTransparency(double theTransparency, const QObjectPtrList& theObjects)
+{
+ foreach(ObjectPtr anObj, theObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+ if (aResult.get() != NULL) {
+ 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);
+ }
+ }
+}
//**************************************************************
void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
{
AttributeDoublePtr aDoubleAttr;
- // 1. find the current color of the object. This is a color of AIS presentation
- // The objects are iterated until a first valid color is found
+ // 1. find the current property of the object. This is a property of AIS presentation
+ // The objects are iterated until a first valid property is found
double aDeflection = -1;
foreach(ObjectPtr anObject, theObjects) {
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
aDeflection = XGUI_CustomPrs::getResultDeflection(aResult);
}
else {
- // TODO: remove the obtaining a color from the AIS object
+ // TODO: remove the obtaining a property from the AIS object
// this does not happen never because:
- // 1. The color can be changed only on results
+ // 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()) {
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++) {
- 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);
updateCommandStatus();
}
+//**************************************************************
+void XGUI_Workshop::changeTransparency(const QObjectPtrList& theObjects)
+{
+ AttributeDoublePtr aDoubleAttr;
+ // 1. find the current property of the object. This is a property of AIS presentation
+ // The objects are iterated until a first valid property is found
+ double aCurrentValue = -1;
+ 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();
+ }
+ }
+ if (aCurrentValue > 0)
+ break;
+ }
+ if (aCurrentValue < 0)
+ return;
+
+ if (!abortAllOperations())
+ return;
+
+ // 2. show the dialog to change the value
+ XGUI_PropertyDialog* aDlg = new XGUI_PropertyDialog(desktop());
+ aDlg->setWindowTitle("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);
+
+ // 3. abort the previous operation and start a new one
+ SessionPtr aMgr = ModelAPI_Session::get();
+ 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);
+
+ aMgr->finishOperation();
+ updateCommandStatus();
+}
+
+//**************************************************************
+void XGUI_Workshop::onTransparencyValueChanged()
+{
+ 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));
+}
+
+//**************************************************************
+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)
{
+ if (isVisible) {
+ std::set<ObjectPtr> anObjects;
+ foreach (ObjectPtr aObj, theList) {
+ anObjects.insert(aObj);
+ }
+ if (!prepareForDisplay(anObjects))
+ return;
+ }
+
foreach (ObjectPtr aObj, theList) {
aObj->setDisplayed(isVisible);
}
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ myObjectBrowser->updateAllIndexes();
}
//**************************************************************
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
+ // Problem in bug 2218
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
#ifdef HAVE_SALOME
//issue #2159 Hide all incomplete behavior
viewer()->eraseAll();
#endif
+ std::set<ObjectPtr> anObjects;
+ foreach (ObjectPtr aObj, aSrcList) {
+ anObjects.insert(aObj);
+ }
+
+ if (!prepareForDisplay(anObjects))
+ 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();
+}
//**************************************************************
void XGUI_Workshop::registerValidators() const
//**************************************************************
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);
}
}
}
objectBrowser()->clearContent();
module()->closeDocument();
+ // we need to clear viewer (with created filters) to do not have problems in 2nd SALOME study
+ module()->clearViewer();
+
// data model need not process the document's signals about objects modifications as
// the document is closed
//objectBrowser()->dataModel()->blockEventsProcessing(isBlocked);
}
+//******************************************************
void XGUI_Workshop::addHistoryMenu(QObject* theObject, const char* theSignal, const char* theSlot)
{
XGUI_HistoryMenu* aMenu = NULL;
connect(aMenu, SIGNAL(actionSelected(int)), this, theSlot);
}
+//******************************************************
QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>& theList) const
{
QList<ActionInfo> aResult;
return aResult;
}
+//******************************************************
void XGUI_Workshop::setStatusBarMessage(const QString& theMessage)
{
#ifdef HAVE_SALOME
#endif
}
+#ifdef HAVE_SALOME
+//******************************************************
void XGUI_Workshop::synchronizeViewer()
{
SessionPtr aMgr = ModelAPI_Session::get();
}
}
+//******************************************************
void XGUI_Workshop::synchronizeGroupInViewer(const DocumentPtr& theDoc,
const std::string& theGroup,
bool theUpdateViewer)
ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
if (aRes.get() && (!aRes->shape().get() || aRes->shape()->isNull()))
continue;
- myDisplayer->display(aObj, false);
+ ResultBodyPtr aResBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aObj);
+ if (aResBody.get())
+ synchronizeResultTree(aResBody, false);
+ else
+ myDisplayer->display(aObj, 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
+ myDisplayer->display(theRes, theUpdateViewer);
+}
+#endif
+
+//******************************************************
void XGUI_Workshop::highlightResults(const QObjectPtrList& theObjects)
{
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"),
tr("Results not found"), QMessageBox::Ok);
}
+//******************************************************
void XGUI_Workshop::highlightFeature(const QObjectPtrList& theObjects)
{
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());
}
}
+
+void XGUI_Workshop::insertFeatureFolder()
+{
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+ if (aObjects.isEmpty())
+ return;
+ ObjectPtr aObj = aObjects.first();
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+ if (aFeature.get() == NULL)
+ return;
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aDoc = aMgr->activeDocument();
+
+ QString aDescription = contextMenuMgr()->action("INSERT_FOLDER_CMD")->text();
+
+ aMgr->startOperation(aDescription.toStdString());
+ aDoc->addFolder(aFeature);
+ aMgr->finishOperation();
+
+ updateCommandStatus();
+}
+
+
+void XGUI_Workshop::insertToFolder(bool isBefore)
+{
+ std::list<FeaturePtr> aFeatures = mySelector->getSelectedFeatures();
+ if (aFeatures.empty())
+ return;
+
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aDoc = aMgr->activeDocument();
+
+ FolderPtr aFolder = isBefore? aDoc->findFolderAbove(aFeatures):
+ aDoc->findFolderBelow(aFeatures);
+ if (!aFolder.get())
+ return;
+
+ 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)
+{
+ std::list<FeaturePtr> aFeatures = mySelector->getSelectedFeatures();
+ if (aFeatures.empty())
+ return;
+
+ 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);
+ }
+ }
+}
\ No newline at end of file
