#include "XGUI_ContextMenuMgr.h"
#include "XGUI_ModuleConnector.h"
#include "XGUI_Preferences.h"
+#include <XGUI_QtEvents.h>
#include <ModelAPI_Events.h>
-#include <ModelAPI_PluginManager.h>
+#include <ModelAPI_Session.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModuleBase_Operation.h>
#include <ModuleBase_OperationDescription.h>
#include <ModuleBase_SelectionValidator.h>
-#include <ModuleBase_ResultValidators.h>
-#include "ModuleBase_WidgetFactory.h"
+#include <ModuleBase_WidgetFactory.h>
+#include <ModuleBase_Tools.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <QPushButton>
#include <QDockWidget>
#include <QLayout>
-#include <QTimer>
+#include <QThread>
+#include <QObject>
#ifdef _DEBUG
#include <QDebug>
+#include <iostream>
#endif
#ifdef WIN32
mySalomeConnector(theConnector),
myPropertyPanel(0),
myObjectBrowser(0),
- myDisplayer(0)
+ myDisplayer(0),
+ myUpdatePrefs(false),
+ myPartActivating(false)
{
myMainWindow = mySalomeConnector ? 0 : new XGUI_MainWindow();
//******************************************************
XGUI_Workshop::~XGUI_Workshop(void)
{
+ delete myDisplayer;
}
//******************************************************
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED));
aLoop->registerListener(this, Events_Loop::eventByName("LongOperation"));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_PLUGIN_LOADED));
+ aLoop->registerListener(this, Events_Loop::eventByName("CurrentDocumentChanged"));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOSHOW));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOHIDE));
registerValidators();
activateModule();
aCommand->connectTo(this, SLOT(onRedo()));
aCommand = aGroup->addFeature("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
- QIcon(":pictures/rebuild.png"));
+ QIcon(":pictures/rebuild.png"), QKeySequence());
+ aCommand->connectTo(this, SLOT(onRebuild()));
aCommand = aGroup->addFeature("SAVEAS_CMD", tr("Save as..."), tr("Save the document into a file"),
- QIcon(":pictures/save.png"));
+ QIcon(":pictures/save.png"), QKeySequence());
aCommand->connectTo(this, SLOT(onSaveAs()));
//aCommand->disable();
}
//******************************************************
-void XGUI_Workshop::processEvent(const Events_Message* theMessage)
+void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMessage)
{
+ if (QApplication::instance()->thread() != QThread::currentThread()) {
+ #ifdef _DEBUG
+ std::cout << "XGUI_Workshop::processEvent: " << "Working in another thread." << std::endl;
+ #endif
+ SessionPtr aMgr = ModelAPI_Session::get();
+ PostponeMessageQtEvent* aPostponeEvent = new PostponeMessageQtEvent(theMessage);
+ QApplication::postEvent(this, aPostponeEvent);
+ return;
+ }
+
//A message to start feature creation received.
if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_FEATURE_LOADED)) {
- const Config_FeatureMessage* aFeatureMsg =
- dynamic_cast<const Config_FeatureMessage*>(theMessage);
+ boost::shared_ptr<Config_FeatureMessage> aFeatureMsg =
+ boost::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
if (!aFeatureMsg->isInternal()) {
addFeature(aFeatureMsg);
}
- return;
}
// Process creation of Part
- if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED)) {
- const ModelAPI_ObjectUpdatedMessage* aUpdMsg =
- dynamic_cast<const ModelAPI_ObjectUpdatedMessage*>(theMessage);
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED)) {
+ boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
onFeatureCreatedMsg(aUpdMsg);
- return;
+ if (myUpdatePrefs) {
+ if (mySalomeConnector)
+ mySalomeConnector->createPreferences();
+ myUpdatePrefs = false;
+ }
+ }
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_PLUGIN_LOADED)) {
+ myUpdatePrefs = true;
}
// Redisplay feature
- if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY)) {
- const ModelAPI_ObjectUpdatedMessage* aUpdMsg =
- dynamic_cast<const ModelAPI_ObjectUpdatedMessage*>(theMessage);
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY)) {
+ boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
onFeatureRedisplayMsg(aUpdMsg);
- return;
}
//Update property panel on corresponding message. If there is no current operation (no
//property panel), or received message has different feature to the current - do nothing.
- if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED)) {
- const ModelAPI_ObjectUpdatedMessage* anUpdateMsg =
- dynamic_cast<const ModelAPI_ObjectUpdatedMessage*>(theMessage);
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED)) {
+ boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
onFeatureUpdatedMsg(anUpdateMsg);
- return;
}
- if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED)) {
- const ModelAPI_ObjectDeletedMessage* aDelMsg =
- dynamic_cast<const ModelAPI_ObjectDeletedMessage*>(theMessage);
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED)) {
+ boost::shared_ptr<ModelAPI_ObjectDeletedMessage> aDelMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
onObjectDeletedMsg(aDelMsg);
- return;
}
- if (theMessage->eventID() == Events_LongOp::eventID()) {
+ else if (theMessage->eventID() == Events_LongOp::eventID()) {
if (Events_LongOp::isPerformed())
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
- //QTimer::singleShot(10, this, SLOT(onStartWaiting()));
else
QApplication::restoreOverrideCursor();
- return;
+ }
+
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TOSHOW)) {
+ boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+ const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
+ QList<ObjectPtr> aList;
+ std::set<ObjectPtr>::const_iterator aIt;
+ for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
+ aList.append(*aIt);
+ showObjects(aList, true);
+ }
+
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TOHIDE)) {
+ boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+ boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+ const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
+ QList<ObjectPtr> aList;
+ std::set<ObjectPtr>::const_iterator aIt;
+ for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
+ aList.append(*aIt);
+ showObjects(aList, false);
}
//An operation passed by message. Start it, process and commit.
- if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OPERATION_LAUNCHED)) {
- const Config_PointerMessage* aPartSetMsg =
- dynamic_cast<const Config_PointerMessage*>(theMessage);
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OPERATION_LAUNCHED)) {
+ boost::shared_ptr<Config_PointerMessage> aPartSetMsg =
+ boost::dynamic_pointer_cast<Config_PointerMessage>(theMessage);
//myPropertyPanel->cleanContent();
ModuleBase_Operation* anOperation = (ModuleBase_Operation*) aPartSetMsg->pointer();
updateCommandStatus();
}
}
- return;
}
- //Show error dialog if error message received.
- const Events_Error* anAppError = dynamic_cast<const Events_Error*>(theMessage);
- if (anAppError) {
- emit errorOccurred(QString::fromLatin1(anAppError->description()));
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName("CurrentDocumentChanged")) {
+ // Find and Activate active part
+ if (myPartActivating)
+ return;
+ myActionsMgr->update();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aActiveDoc = aMgr->activeDocument();
+ DocumentPtr aDoc = aMgr->moduleDocument();
+ if (aActiveDoc == aDoc) {
+ activatePart(ResultPartPtr());
+ return;
+ }
+ std::string aGrpName = ModelAPI_ResultPart::group();
+ for (int i = 0; i < aDoc->size(aGrpName); i++) {
+ ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aDoc->object(aGrpName, i));
+ if (aPart->partDoc() == aActiveDoc) {
+ activatePart(aPart); // Activate a part which corresponds to active Doc
+ return;
+ }
+ }
+ // If not found then activate global document
+ activatePart(ResultPartPtr());
+
+ } else {
+ //Show error dialog if error message received.
+ boost::shared_ptr<Events_Error> anAppError = boost::dynamic_pointer_cast<Events_Error>(theMessage);
+ if (anAppError) {
+ emit errorOccurred(QString::fromLatin1(anAppError->description()));
+ }
+ }
+ if (!isSalomeMode()) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->isModified() != myMainWindow->isModifiedState())
+ myMainWindow->setModifiedState(aMgr->isModified());
}
}
+
//******************************************************
void XGUI_Workshop::onStartWaiting()
{
}
//******************************************************
-void XGUI_Workshop::onFeatureUpdatedMsg(const ModelAPI_ObjectUpdatedMessage* theMsg)
+void XGUI_Workshop::onFeatureUpdatedMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
{
std::set<ObjectPtr> aFeatures = theMsg->objects();
if (myOperationMgr->hasOperation()) {
}
}
}
- myOperationMgr->validateCurrentOperation();
+ myOperationMgr->onValidateOperation();
+ if (myObjectBrowser)
+ myObjectBrowser->processEvent(theMsg);
}
//******************************************************
-void XGUI_Workshop::onFeatureRedisplayMsg(const ModelAPI_ObjectUpdatedMessage* theMsg)
+void XGUI_Workshop::onFeatureRedisplayMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
{
std::set<ObjectPtr> aObjects = theMsg->objects();
std::set<ObjectPtr>::const_iterator aIt;
for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
ObjectPtr aObj = (*aIt);
- if (!aObj->data() || !aObj->data()->isValid())
+ if (!aObj->data() || !aObj->data()->isValid() || aObj->document()->isConcealed(aObj))
myDisplayer->erase(aObj, false);
else {
- if (myDisplayer->isVisible(aObj)) // TODO VSV: Correction sketch drawing
+ if (myDisplayer->isVisible(aObj)) {
myDisplayer->display(aObj, false); // In order to update presentation
- else {
if (myOperationMgr->hasOperation()) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
- if (aOperation->hasObject(aObj)) { // Display only current operation results
+ if (!aOperation->hasObject(aObj))
+ if (!myDisplayer->isActive(aObj))
+ myDisplayer->activate(aObj);
+ }
+ } else {
+ if (myOperationMgr->hasOperation()) {
+ ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
+ // Display only current operation results if operation has preview
+ if (aOperation->hasObject(aObj) && aOperation->hasPreview()) {
myDisplayer->display(aObj, false);
+ // Deactivate object of current operation from selection
+ if (myDisplayer->isActive(aObj))
+ myDisplayer->deactivate(aObj);
}
}
}
}
//******************************************************
-void XGUI_Workshop::onFeatureCreatedMsg(const ModelAPI_ObjectUpdatedMessage* theMsg)
+void XGUI_Workshop::onFeatureCreatedMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
{
std::set<ObjectPtr> aObjects = theMsg->objects();
// it doesn't stored in the operation mgr and doesn't displayed
} else if (myOperationMgr->hasOperation()) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
- if (aOperation->hasObject(*aIt)) { // Display only current operation results
+ if (!(*aIt)->document()->isConcealed(*aIt) &&
+ aOperation->hasObject(*aIt)) { // Display only current operation results
myDisplayer->display(*aIt, false);
isDisplayed = true;
}
}
}
+ if (myObjectBrowser)
+ myObjectBrowser->processEvent(theMsg);
if (isDisplayed)
myDisplayer->updateViewer();
- if (aHasPart) {
- //The created part will be created in Object Browser later and we have to activate it
- // only when it is created everywere
- QTimer::singleShot(50, this, SLOT(activateLastPart()));
- }
+ //if (aHasPart) { // TODO: Avoid activate last part on loading of document
+ // activateLastPart();
+ //}
}
//******************************************************
-void XGUI_Workshop::onObjectDeletedMsg(const ModelAPI_ObjectDeletedMessage* theMsg)
+void XGUI_Workshop::onObjectDeletedMsg(const boost::shared_ptr<ModelAPI_ObjectDeletedMessage>& theMsg)
{
+ if (myObjectBrowser)
+ myObjectBrowser->processEvent(theMsg);
//std::set<ObjectPtr> aFeatures = theMsg->objects();
}
void XGUI_Workshop::onOperationStarted()
{
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
-
+ if (this->isSalomeMode())
+ aOperation->setNestedFeatures(mySalomeConnector->nestedActions(aOperation->id()));
+ else
+ aOperation->setNestedFeatures(myActionsMgr->nestedCommands(aOperation->id()));
+
if (aOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
connectWithOperation(aOperation);
myPropertyPanel->cleanContent();
aFactory.createWidget(myPropertyPanel->contentWidget());
+ ModuleBase_Tools::zeroMargins(myPropertyPanel->contentWidget());
QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
for (; anIt != aLast; anIt++) {
aWidget = *anIt;
aWidget->setFeature(aOperation->feature());
- //QObject::connect(aWidget, SIGNAL(valuesChanged()), aOperation, SLOT(storeCustomValue()));
+ aWidget->enableFocusProcessing();
QObject::connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
// Init default values
- if (!aOperation->isEditOperation() && aWidget->hasDefaultValue()) {
- //aWidget->storeValue(aOperation->feature());
-
+ if (!aOperation->isEditOperation() && !aWidget->isComputedDefault()) {
aWidget->storeValue();
}
}
+ aOperation->setPropertyPanel(myPropertyPanel);
myPropertyPanel->setModelWidgets(aWidgets);
- myPropertyPanel->setWindowTitle(aOperation->getDescription()->description());
+ myPropertyPanel->activateNextWidget(NULL);
+ // Widget activation (from the previous method) may commit the current operation
+ // if pre-selection is enougth for it. So we shouldn't update prop panel's title
+ if(myOperationMgr->isCurrentOperation(aOperation)) {
+ myPropertyPanel->setWindowTitle(aOperation->getDescription()->description());
+ }
}
updateCommandStatus();
}
myPropertyPanel->cleanContent();
}
+bool XGUI_Workshop::event(QEvent * theEvent)
+{
+ PostponeMessageQtEvent* aPostponedEv = dynamic_cast<PostponeMessageQtEvent*>(theEvent);
+ if (aPostponedEv) {
+ boost::shared_ptr<Events_Message> aEventPtr = aPostponedEv->postponedMessage();
+ processEvent(aEventPtr);
+ return true;
+ }
+ return false;
+}
+
/*
*
*/
-void XGUI_Workshop::addFeature(const Config_FeatureMessage* theMessage)
+void XGUI_Workshop::addFeature(const boost::shared_ptr<Config_FeatureMessage>& theMessage)
{
if (!theMessage) {
#ifdef _DEBUG
QString::fromStdString(theMessage->text()),
QString::fromStdString(theMessage->tooltip()),
QIcon(theMessage->icon().c_str()),
- QKeySequence(), isUsePropPanel);
- salomeConnector()->setNestedActions(aFeatureId, aNestedFeatures.split(" "));
+ QKeySequence(),
+ isUsePropPanel);
+ salomeConnector()->setNestedActions(aFeatureId, aNestedFeatures.split(" ", QString::SkipEmptyParts));
myActionsMgr->addCommand(aAction);
myModule->featureCreated(aAction);
} else {
if (!aGroup) {
aGroup = aPage->addGroup(aGroupName);
}
+ QString aDocKind = QString::fromStdString(theMessage->documentKind());
// Check if hotkey sequence is already defined:
QKeySequence aHotKey = myActionsMgr->registerShortcut(
QString::fromStdString(theMessage->keysequence()));
XGUI_Command* aCommand = aGroup->addFeature(aFeatureId,
QString::fromStdString(theMessage->text()),
QString::fromStdString(theMessage->tooltip()),
- QIcon(theMessage->icon().c_str()), aHotKey,
+ QIcon(theMessage->icon().c_str()),
+ aDocKind,
+ aHotKey,
isUsePropPanel);
aCommand->setNestedCommands(aNestedFeatures.split(" ", QString::SkipEmptyParts));
myActionsMgr->addCommand(aCommand);
aCommand = salomeConnector()->command(theOperation->getDescription()->operationId());
} else {
XGUI_MainMenu* aMenu = myMainWindow->menuObject();
- aCommand = aMenu->feature(theOperation->getDescription()->operationId());
+ FeaturePtr aFeature = theOperation->feature();
+ if(aFeature)
+ aCommand = aMenu->feature(QString::fromStdString(aFeature->getKind()));
}
//Abort operation on uncheck the command
- if (aCommand)
+ if (aCommand) {
connect(aCommand, SIGNAL(triggered(bool)), theOperation, SLOT(setRunning(bool)));
+ }
}
/*
* Saves document with given name.
*/
-void XGUI_Workshop::saveDocument(QString theName)
+void XGUI_Workshop::saveDocument(const QString& theName, std::list<std::string>& theFileNames)
{
QApplication::restoreOverrideCursor();
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
- aDoc->save(theName.toLatin1().constData());
+ SessionPtr aMgr = ModelAPI_Session::get();
+ aMgr->save(theName.toLatin1().constData(), theFileNames);
QApplication::restoreOverrideCursor();
}
+bool XGUI_Workshop::isActiveOperationAborted()
+{
+ return myOperationMgr->abortAllOperations();
+}
+
//******************************************************
void XGUI_Workshop::onExit()
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
- if (aDoc->isModified()) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->isModified()) {
int anAnswer = QMessageBox::question(
myMainWindow, tr("Save current file"), tr("The document is modified, save before exit?"),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Cancel);
//******************************************************
void XGUI_Workshop::onOpen()
{
+ if(!isActiveOperationAborted())
+ return;
//save current file before close if modified
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
- if (aDoc->isModified()) {
+ SessionPtr aSession = ModelAPI_Session::get();
+ if (aSession->isModified()) {
//TODO(sbh): re-launch the app?
int anAnswer = QMessageBox::question(
myMainWindow, tr("Save current file"),
} else if (anAnswer == QMessageBox::Cancel) {
return;
}
- aDoc->close();
+ aSession->moduleDocument()->close();
myCurrentDir = "";
}
return;
}
QApplication::setOverrideCursor(Qt::WaitCursor);
- aDoc->load(myCurrentDir.toLatin1().constData());
+ aSession->load(myCurrentDir.toLatin1().constData());
myObjectBrowser->rebuildDataTree();
displayAllResults();
updateCommandStatus();
//******************************************************
bool XGUI_Workshop::onSave()
{
+ if(!isActiveOperationAborted())
+ return false;
if (myCurrentDir.isEmpty()) {
return onSaveAs();
}
- saveDocument(myCurrentDir);
+ std::list<std::string> aFiles;
+ saveDocument(myCurrentDir, aFiles);
updateCommandStatus();
+ myMainWindow->setModifiedState(false);
return true;
}
//******************************************************
bool XGUI_Workshop::onSaveAs()
{
+ if(!isActiveOperationAborted())
+ return false;
QFileDialog dialog(mainWindow());
dialog.setWindowTitle(tr("Select directory to save files..."));
dialog.setFileMode(QFileDialog::Directory);
}
}
myCurrentDir = aTempDir;
+ if (!isSalomeMode()) {
+ myMainWindow->setCurrentDir(myCurrentDir, false);
+ myMainWindow->setModifiedState(false);
+ }
return onSave();
}
void XGUI_Workshop::onUndo()
{
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
- if (aDoc->isOperation())
- operationMgr()->abortOperation();
- aDoc->undo();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->isOperation())
+ operationMgr()->onAbortOperation();
+ aMgr->undo();
updateCommandStatus();
}
void XGUI_Workshop::onRedo()
{
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
- if (aDoc->isOperation())
- operationMgr()->abortOperation();
- aDoc->redo();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->isOperation())
+ operationMgr()->onAbortOperation();
+ aMgr->redo();
updateCommandStatus();
}
+//******************************************************
+void XGUI_Workshop::onRebuild()
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ bool aWasOperation = aMgr->isOperation(); // keep this value
+ if (!aWasOperation) {
+ aMgr->startOperation();
+ }
+ static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
+ Events_Loop::loop()->send(boost::shared_ptr<Events_Message>(
+ new Events_Message(aRebuildEvent, this)));
+ if (!aWasOperation) {
+ aMgr->finishOperation();
+ }
+}
+
//******************************************************
void XGUI_Workshop::onPreferences()
{
if (!err.isEmpty()) {
if (mainWindow()) {
- QMessageBox::warning(mainWindow(), tr("Error"), err);
+ Events_Error::send(err.toStdString());
} else {
qWarning(qPrintable(err));
}
foreach (XGUI_Command* aCmd, aMenuBar->features())
aCommands.append(aCmd);
}
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- if (aMgr->hasRootDocument()) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ if (aMgr->hasModuleDocument()) {
QAction* aUndoCmd;
QAction* aRedoCmd;
- foreach(QAction* aCmd, aCommands)
- {
+ foreach(QAction* aCmd, aCommands) {
QString aId = aCmd->data().toString();
if (aId == "UNDO_CMD")
aUndoCmd = aCmd;
// Enable all commands
aCmd->setEnabled(true);
}
- DocumentPtr aDoc = aMgr->rootDocument();
- aUndoCmd->setEnabled(aDoc->canUndo());
- aRedoCmd->setEnabled(aDoc->canRedo());
+ aUndoCmd->setEnabled(aMgr->canUndo());
+ aRedoCmd->setEnabled(aMgr->canRedo());
} else {
- foreach(QAction* aCmd, aCommands)
- {
+ foreach(QAction* aCmd, aCommands) {
QString aId = aCmd->data().toString();
if (aId == "NEW_CMD")
aCmd->setEnabled(true);
QDockWidget* XGUI_Workshop::createObjectBrowser(QWidget* theParent)
{
QDockWidget* aObjDock = new QDockWidget(theParent);
- aObjDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
+ aObjDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea);
aObjDock->setWindowTitle(tr("Object browser"));
aObjDock->setStyleSheet(
"::title { position: relative; padding-left: 5px; text-align: left center }");
QDockWidget* aObjDock = createObjectBrowser(aDesktop);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
myPropertyPanel = new XGUI_PropertyPanel(aDesktop);
+ myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
hidePropertyPanel(); //<! Invisible by default
hideObjectBrowser();
connect(aOkBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onCommitOperation()));
QPushButton* aCancelBtn = myPropertyPanel->findChild<QPushButton*>(XGUI::PROP_PANEL_CANCEL);
connect(aCancelBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onAbortOperation()));
-
- connect(myPropertyPanel, SIGNAL(keyReleased(const std::string&, QKeyEvent*)), myOperationMgr,
- SLOT(onKeyReleased(const std::string&, QKeyEvent*)));
-
- connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), myOperationMgr,
- SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
- connect(myOperationMgr, SIGNAL(activateNextWidget(ModuleBase_ModelWidget*)), myPropertyPanel,
- SLOT(onActivateNextWidget(ModuleBase_ModelWidget*)));
+ connect(myPropertyPanel, SIGNAL(keyReleased(QKeyEvent*)), myOperationMgr,
+ SLOT(onKeyReleased(QKeyEvent*)));
+ //connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), myOperationMgr,
+ // SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
+ //connect(myOperationMgr, SIGNAL(activateNextWidget(ModuleBase_ModelWidget*)), myPropertyPanel,
+ // SLOT(onActivateNextWidget(ModuleBase_ModelWidget*)));
connect(myOperationMgr, SIGNAL(operationValidated(bool)), myPropertyPanel,
SLOT(setAcceptEnabled(bool)));
//******************************************************
void XGUI_Workshop::changeCurrentDocument(ObjectPtr theObj)
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
+ SessionPtr aMgr = ModelAPI_Session::get();
if (theObj) {
ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(theObj);
if (aPart) {
DocumentPtr aPartDoc = aPart->partDoc();
if (aPartDoc) {
- aMgr->setCurrentDocument(aPartDoc);
+ aMgr->setActiveDocument(aPartDoc);
return;
}
}
}
- aMgr->setCurrentDocument(aMgr->rootDocument());
+ aMgr->setActiveDocument(aMgr->moduleDocument());
}
//******************************************************
showObjects(aObjects, true);
else if (theId == "HIDE_CMD")
showObjects(aObjects, false);
+ else if (theId == "SHOW_ONLY_CMD")
+ showOnlyObjects(aObjects);
+ else if (theId == "SHADING_CMD")
+ setDisplayMode(aObjects, XGUI_Displayer::Shading);
+ else if (theId == "WIREFRAME_CMD")
+ setDisplayMode(aObjects, XGUI_Displayer::Wireframe);
+ else if (theId == "HIDEALL_CMD")
+ myDisplayer->eraseAll();
}
//**************************************************************
//**************************************************************
void XGUI_Workshop::activatePart(ResultPartPtr theFeature)
{
- changeCurrentDocument(theFeature);
- myObjectBrowser->activatePart(theFeature);
+ if (!myPartActivating) {
+ myPartActivating = true;
+ if (theFeature)
+ theFeature->activate();
+ changeCurrentDocument(theFeature);
+ myObjectBrowser->activatePart(theFeature);
+ myPartActivating = false;
+ }
}
//**************************************************************
void XGUI_Workshop::activateLastPart()
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aDoc = aMgr->rootDocument();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aDoc = aMgr->moduleDocument();
std::string aGrpName = ModelAPI_ResultPart::group();
ObjectPtr aLastPart = aDoc->object(aGrpName, aDoc->size(aGrpName) - 1);
ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aLastPart);
- if (aPart)
+ if (aPart) {
activatePart(aPart);
+ }
}
//**************************************************************
QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
// ToDo: definbe deleting method
if (aRes == QMessageBox::Yes) {
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- aMgr->rootDocument()->startOperation();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ aMgr->startOperation();
foreach (ObjectPtr aObj, theList)
{
ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
if (aPart) {
DocumentPtr aDoc = aPart->document();
- if (aDoc == aMgr->currentDocument()) {
+ if (aDoc == aMgr->activeDocument()) {
aDoc->close();
}
- //aMgr->rootDocument()->removeFeature(aPart->owner());
+ //aMgr->moduleDocument()->removeFeature(aPart->owner());
} else {
FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
if (aFeature)
}
}
myDisplayer->updateViewer();
- aMgr->rootDocument()->finishOperation();
+ aMgr->finishOperation();
}
}
myDisplayer->updateViewer();
}
+//**************************************************************
+void XGUI_Workshop::showOnlyObjects(const QList<ObjectPtr>& theList)
+{
+ myDisplayer->eraseAll(false);
+ showObjects(theList, true);
+}
+
+
//**************************************************************
void XGUI_Workshop::updateCommandsOnViewSelection()
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
XGUI_Selection* aSelection = mySelector->selection();
if (aSelection->getSelected().size() == 0)
return;
+ // Restrict validators to manage only nested (child) features
+ // of the current feature i.e. if current feature is Sketch -
+ // Sketch Features & Constraints can be validated.
+ QStringList aNestedIds;
+ if(myOperationMgr->hasOperation()) {
+ FeaturePtr aFeature = myOperationMgr->currentOperation()->feature();
+ if(aFeature) {
+ aNestedIds << myActionsMgr->nestedCommands(QString::fromStdString(aFeature->getKind()));
+ }
+ }
+ SessionPtr aMgr = ModelAPI_Session::get();
+ ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
QList<QAction*> aActions = getModuleCommands();
- foreach(QAction* aAction, aActions)
- {
+ foreach(QAction* aAction, aActions) {
QString aId = aAction->data().toString();
+ if(!aNestedIds.contains(aId))
+ continue;
std::list<ModelAPI_Validator*> aValidators;
- aFactory->validators(aId.toStdString(), aValidators);
+ std::list<std::list<std::string> > anArguments;
+ aFactory->validators(aId.toStdString(), aValidators, anArguments);
std::list<ModelAPI_Validator*>::iterator aValidator = aValidators.begin();
for (; aValidator != aValidators.end(); aValidator++) {
if (*aValidator) {
//**************************************************************
void XGUI_Workshop::registerValidators() const
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
+ SessionPtr aMgr = ModelAPI_Session::get();
ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
}
//**************************************************************
void XGUI_Workshop::displayAllResults()
{
- PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
- DocumentPtr aRootDoc = aMgr->rootDocument();
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aRootDoc = aMgr->moduleDocument();
displayDocumentResults(aRootDoc);
for (int i = 0; i < aRootDoc->size(ModelAPI_ResultPart::group()); i++) {
ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), i);
//**************************************************************
void XGUI_Workshop::displayDocumentResults(DocumentPtr theDoc)
{
+ if (!theDoc)
+ return;
displayGroupResults(theDoc, ModelAPI_ResultConstruction::group());
displayGroupResults(theDoc, ModelAPI_ResultBody::group());
}
for (int i = 0; i < theDoc->size(theGroup); i++)
myDisplayer->display(theDoc->object(theGroup, i), false);
}
+
+//**************************************************************
+void XGUI_Workshop::setDisplayMode(const QList<ObjectPtr>& theList, int theMode)
+{
+ foreach(ObjectPtr aObj, theList) {
+ myDisplayer->setDisplayMode(aObj, (XGUI_Displayer::DisplayMode)theMode, false);
+ }
+ if (theList.size() > 0)
+ myDisplayer->updateViewer();
+}