#include "XGUI_ContextMenuMgr.h"
#include "XGUI_ModuleConnector.h"
#include <XGUI_QtEvents.h>
+#include <XGUI_HistoryMenu.h>
#include <AppElements_Workbench.h>
#include <AppElements_Viewer.h>
#include <AppElements_MainMenu.h>
#include <AppElements_MainWindow.h>
#include <AppElements_MenuGroupPanel.h>
+#include <AppElements_Button.h>
#include <ModuleBase_IModule.h>
#include <ModuleBase_Preferences.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_ResultBody.h>
+#include <ModelAPI_AttributeIntArray.h>
//#include <PartSetPlugin_Part.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_IViewer.h>
#include<ModuleBase_FilterFactory.h>
+#include <ModuleBase_PageBase.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <QLayout>
#include <QThread>
#include <QObject>
+#include <QMenu>
+#include <QToolButton>
+#include <QAction>
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QHBoxLayout>
+#include <QtxColorButton.h>
#ifdef _DEBUG
#include <QDebug>
QIcon(":pictures/undo.png"),
QKeySequence::Undo, false, "MEN_DESK_EDIT");
connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onUndo()));
+ addHistoryMenu(aAction, SIGNAL(updateUndoHistory(const QList<ActionInfo>&)), SLOT(onUndo(int)));
+
aAction = salomeConnector()->addDesktopCommand("REDO_CMD", tr("Redo"), tr("Redo last command"),
QIcon(":pictures/redo.png"), QKeySequence::Redo,
false, "MEN_DESK_EDIT");
connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onRedo()));
+ 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(),
aCommand->connectTo(this, SLOT(onSave()));
//aCommand->disable();
- aCommand = aGroup->addFeature("UNDO_CMD", tr("Undo"), tr("Undo last command"),
+ QString aUndoId = "UNDO_CMD";
+ aCommand = aGroup->addFeature(aUndoId, tr("Undo"), tr("Undo last command"),
QIcon(":pictures/undo.png"), QKeySequence::Undo);
aCommand->connectTo(this, SLOT(onUndo()));
+ AppElements_Button* aUndoButton = qobject_cast<AppElements_Button*>(aGroup->widget(aUndoId));
+ addHistoryMenu(aUndoButton,
+ SIGNAL(updateUndoHistory(const QList<ActionInfo>&)),
+ SLOT(onUndo(int)));
- aCommand = aGroup->addFeature("REDO_CMD", tr("Redo"), tr("Redo last command"),
+ QString aRedoId = "REDO_CMD";
+ aCommand = aGroup->addFeature(aRedoId, tr("Redo"), tr("Redo last command"),
QIcon(":pictures/redo.png"), QKeySequence::Redo);
aCommand->connectTo(this, SLOT(onRedo()));
+ AppElements_Button* aRedoButton = qobject_cast<AppElements_Button*>(aGroup->widget(aRedoId));
+ addHistoryMenu(aRedoButton,
+ SIGNAL(updateRedoHistory(const QList<ActionInfo>&)),
+ SLOT(onRedo(int)));
aCommand = aGroup->addFeature("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
QIcon(":pictures/rebuild.png"), QKeySequence());
aMsg->parameters());
}
}
- }
-
-
- else {
+ } else {
//Show error dialog if error message received.
std::shared_ptr<Events_Error> anAppError = std::dynamic_pointer_cast<Events_Error>(theMessage);
if (anAppError) {
emit errorOccurred(QString::fromLatin1(anAppError->description()));
}
+ return;
}
if (!isSalomeMode()) {
SessionPtr aMgr = ModelAPI_Session::get();
}
}
+//******************************************************
+QMainWindow* XGUI_Workshop::desktop() const
+{
+ return isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
+}
//******************************************************
void XGUI_Workshop::onStartWaiting()
setNestedFeatures(theOperation);
if (theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
- connectWithOperation(theOperation);
+ // connectWithOperation(theOperation); already connected
setPropertyPanel(theOperation);
}
updateCommandStatus();
myPropertyPanel->cleanContent();
aFactory.createWidget(myPropertyPanel->contentWidget());
- ModuleBase_Tools::zeroMargins(myPropertyPanel->contentWidget());
QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
- aWidget->setFeature(theOperation->feature());
+ bool isStoreValue = !theOperation->isEditOperation() &&
+ !aWidget->getDefaultValue().empty() &&
+ !aWidget->isComputedDefault();
+ aWidget->setFeature(theOperation->feature(), isStoreValue);
aWidget->enableFocusProcessing();
- QObject::connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
- // Init default values
- if (!theOperation->isEditOperation() && aWidget->isValueDefault() && !aWidget->isComputedDefault()) {
- aWidget->storeValue();
- }
}
myPropertyPanel->setModelWidgets(aWidgets);
#endif
return;
}
+ ActionInfo aFeatureInfo;
+ aFeatureInfo.initFrom(theMessage);
// Remember features icons
- myIcons[QString::fromStdString(theMessage->id())] = QString::fromStdString(theMessage->icon());
+ myIcons[QString::fromStdString(theMessage->id())] = aFeatureInfo.iconFile;
- //Find or create Workbench
QString aWchName = QString::fromStdString(theMessage->workbenchId());
- QString aNestedFeatures = QString::fromStdString(theMessage->nestedFeatures());
- bool isUsePropPanel = theMessage->isUseInput();
- QString aFeatureId = QString::fromStdString(theMessage->id());
+ QStringList aNestedFeatures =
+ QString::fromStdString(theMessage->nestedFeatures()).split(" ", QString::SkipEmptyParts);
+ QString aDocKind = QString::fromStdString(theMessage->documentKind());
if (isSalomeMode()) {
- QAction* aAction = salomeConnector()->addFeature(aWchName, aFeatureId,
- QString::fromStdString(theMessage->text()),
- QString::fromStdString(theMessage->tooltip()),
- QIcon(theMessage->icon().c_str()),
- QKeySequence(),
- isUsePropPanel);
- salomeConnector()->setNestedActions(aFeatureId, aNestedFeatures.split(" ", QString::SkipEmptyParts));
- salomeConnector()->setDocumentKind(aFeatureId, QString::fromStdString(theMessage->documentKind()));
+ QAction* aAction = salomeConnector()->addFeature(aWchName, aFeatureInfo);
+ salomeConnector()->setNestedActions(aFeatureInfo.id, aNestedFeatures);
+ salomeConnector()->setDocumentKind(aFeatureInfo.id, aDocKind);
myActionsMgr->addCommand(aAction);
myModule->actionCreated(aAction);
} else {
-
+ //Find or create Workbench
AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
AppElements_Workbench* aPage = aMenuBar->findWorkbench(aWchName);
if (!aPage) {
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()));
+ QKeySequence aHotKey = myActionsMgr->registerShortcut(aFeatureInfo.shortcut);
+ if(aHotKey != aFeatureInfo.shortcut) {
+ aFeatureInfo.shortcut = aHotKey;
+ }
// Create feature...
- AppElements_Command* aCommand = aGroup->addFeature(aFeatureId,
- QString::fromStdString(theMessage->text()),
- QString::fromStdString(theMessage->tooltip()),
- QIcon(theMessage->icon().c_str()),
- aDocKind,
- aHotKey,
- isUsePropPanel);
- aCommand->setNestedCommands(aNestedFeatures.split(" ", QString::SkipEmptyParts));
+ AppElements_Command* aCommand = aGroup->addFeature(aFeatureInfo,
+ aDocKind,
+ aNestedFeatures);
+ // Enrich created button with accept/abort buttons if necessary
+ AppElements_Button* aButton = aCommand->button();
+ if (aButton->isColumnButton()) {
+ QString aNestedActions = QString::fromStdString(theMessage->actionsWhenNested());
+ QList<QAction*> anActList;
+ if (aNestedActions.contains("accept")) {
+ QAction* anAction = myActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll, aButton);
+ connect(anAction, SIGNAL(triggered()), myOperationMgr, SLOT(commitAllOperations()));
+ anActList << anAction;
+ }
+ if (aNestedActions.contains("abort")) {
+ QAction* anAction = myActionsMgr->operationStateAction(XGUI_ActionsMgr::AbortAll, aButton);
+ connect(anAction, SIGNAL(triggered()), myOperationMgr, SLOT(abortAllOperations()));
+ anActList << anAction;
+ }
+ aButton->setAdditionalButtons(anActList);
+ }
myActionsMgr->addCommand(aCommand);
myModule->actionCreated(aCommand);
}
}
//******************************************************
-void XGUI_Workshop::onUndo()
+void XGUI_Workshop::onUndo(int theTimes)
{
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
SessionPtr aMgr = ModelAPI_Session::get();
if (aMgr->isOperation())
operationMgr()->onAbortOperation();
- aMgr->undo();
+ for (int i = 0; i < theTimes; ++i) {
+ aMgr->undo();
+ }
updateCommandStatus();
}
//******************************************************
-void XGUI_Workshop::onRedo()
+void XGUI_Workshop::onRedo(int theTimes)
{
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
SessionPtr aMgr = ModelAPI_Session::get();
if (aMgr->isOperation())
operationMgr()->onAbortOperation();
- aMgr->redo();
+ for (int i = 0; i < theTimes; ++i) {
+ aMgr->redo();
+ }
updateCommandStatus();
}
SessionPtr aMgr = ModelAPI_Session::get();
bool aWasOperation = aMgr->isOperation(); // keep this value
if (!aWasOperation) {
- aMgr->startOperation();
+ aMgr->startOperation("Rebuild");
}
static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
Events_Loop::loop()->send(std::shared_ptr<Events_Message>(
// Enable all commands
aCmd->setEnabled(true);
}
- aUndoCmd->setEnabled(aMgr->canUndo() && !aMgr->isOperation());
- aRedoCmd->setEnabled(aMgr->canRedo() && !aMgr->isOperation());
+
+ aUndoCmd->setEnabled(myModule->canUndo());
+ aRedoCmd->setEnabled(myModule->canRedo());
+ updateHistory();
} else {
foreach(QAction* aCmd, aCommands) {
QString aId = aCmd->data().toString();
emit commandStatusUpdated();
}
+void XGUI_Workshop::updateHistory()
+{
+ std::list<std::string> aUndoList = ModelAPI_Session::get()->undoList();
+ QList<ActionInfo> aUndoRes = processHistoryList(aUndoList);
+ emit updateUndoHistory(aUndoRes);
+
+ std::list<std::string> aRedoList = ModelAPI_Session::get()->redoList();
+ QList<ActionInfo> aRedoRes = processHistoryList(aRedoList);
+ emit updateRedoHistory(aRedoRes);
+}
+
//******************************************************
QDockWidget* XGUI_Workshop::createObjectBrowser(QWidget* theParent)
{
QDockWidget* aObjDock = createObjectBrowser(aDesktop);
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
myPropertyPanel = new XGUI_PropertyPanel(aDesktop);
+ myPropertyPanel->setupActions(myActionsMgr);
myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea);
-
- connect(myPropertyPanel, SIGNAL(noMoreWidgets()), myModule, SLOT(onNoMoreWidgets()));
-
aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
hidePropertyPanel(); ///<! Invisible by default
hideObjectBrowser();
aDesktop->tabifyDockWidget(aObjDock, myPropertyPanel);
myPropertyPanel->installEventFilter(myOperationMgr);
- QPushButton* aOkBtn = myPropertyPanel->findChild<QPushButton*>(PROP_PANEL_OK);
- connect(aOkBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onCommitOperation()));
- QPushButton* aCancelBtn = myPropertyPanel->findChild<QPushButton*>(PROP_PANEL_CANCEL);
- connect(aCancelBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onAbortOperation()));
- connect(myPropertyPanel, SIGNAL(keyReleased(QKeyEvent*)), myOperationMgr,
- SLOT(onKeyReleased(QKeyEvent*)));
- connect(myOperationMgr, SIGNAL(applyEnableChanged(bool)), myPropertyPanel,
- SLOT(setAcceptEnabled(bool)));
+ QAction* aOkAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
+ connect(aOkAct, SIGNAL(triggered()), myOperationMgr, SLOT(onCommitOperation()));
+ QAction* aCancelAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Abort);
+ connect(aCancelAct, SIGNAL(triggered()), myOperationMgr, SLOT(onAbortOperation()));
+ connect(myPropertyPanel, SIGNAL(noMoreWidgets()), myModule, SLOT(onNoMoreWidgets()));
+ connect(myPropertyPanel, SIGNAL(keyReleased(QKeyEvent*)),
+ myOperationMgr, SLOT(onKeyReleased(QKeyEvent*)));
+ connect(myOperationMgr, SIGNAL(validationStateChanged(bool)),
+ aOkAct, SLOT(setEnabled(bool)));
+ QAction* aAcceptAllAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll);
+ connect(myOperationMgr, SIGNAL(nestedStateChanged(bool)),
+ aAcceptAllAct, SLOT(setEnabled(bool)));
}
activatePart(ResultPartPtr());
else if (theId == "DELETE_CMD")
deleteObjects(aObjects);
+ else if (theId == "COLOR_CMD")
+ changeColor(aObjects);
else if (theId == "SHOW_CMD")
showObjects(aObjects, true);
else if (theId == "HIDE_CMD")
}
}
-//**************************************************************
-void XGUI_Workshop::onWidgetValuesChanged()
-{
- ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
- FeaturePtr aFeature = anOperation->feature();
-
- ModuleBase_ModelWidget* aSenderWidget = dynamic_cast<ModuleBase_ModelWidget*>(sender());
-
- const QList<ModuleBase_ModelWidget*>& aWidgets = myPropertyPanel->modelWidgets();
- QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
- for (; anIt != aLast; anIt++) {
- ModuleBase_ModelWidget* aCustom = *anIt;
- if (aCustom && (aCustom == aSenderWidget)) {
- aCustom->storeValue();
- }
- }
-}
-
//**************************************************************
void XGUI_Workshop::activatePart(ResultPartPtr theFeature)
{
//**************************************************************
void XGUI_Workshop::deleteObjects(const QObjectPtrList& theList)
{
+ ModuleBase_IModule* aModule = module();
+ if (aModule->deleteObjects())
+ return;
+
+ if (!isActiveOperationAborted())
+ return;
+
QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
- QMessageBox::StandardButton aRes = QMessageBox::warning(
- aDesktop, tr("Delete features"), tr("Seleted features will be deleted. Continue?"),
- QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
- // ToDo: definbe deleting method
- if (aRes == QMessageBox::Yes) {
- SessionPtr aMgr = ModelAPI_Session::get();
- aMgr->startOperation();
- foreach (ObjectPtr aObj, theList)
- {
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
- if (aPart) {
- DocumentPtr aDoc = aPart->document();
- if (aDoc == aMgr->activeDocument()) {
- aDoc->close();
+ std::set<FeaturePtr> aRefFeatures;
+ foreach (ObjectPtr aObj, theList)
+ {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
+ if (aPart) {
+ // TODO: check for what there is this condition. It is placed here historicaly because
+ // ther is this condition during remove features.
+ } else {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+ if (aFeature.get() != NULL) {
+ aObj->document()->refsToFeature(aFeature, aRefFeatures, false);
+ }
+ }
+ }
+
+ if (!aRefFeatures.empty()) {
+ QStringList aRefNames;
+ std::set<FeaturePtr>::const_iterator anIt = aRefFeatures.begin(),
+ aLast = aRefFeatures.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aFeature = (*anIt);
+ std::string aFName = aFeature->data()->name().c_str();
+ std::string aName = (*anIt)->name().c_str();
+ aRefNames.append((*anIt)->name().c_str());
+ }
+ QString aNames = aRefNames.join(", ");
+
+ QMessageBox::StandardButton aRes = QMessageBox::warning(
+ aDesktop, tr("Delete features"),
+ QString(tr("Selected features are used in the following features: %1.\
+These features will be deleted also. Would you like to continue?")).arg(aNames),
+ QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
+ if (aRes != QMessageBox::Yes)
+ return;
+ }
+
+ QString aDescription = tr("Delete %1");
+ QStringList aObjectNames;
+ foreach (ObjectPtr aObj, theList) {
+ if (!aObj->data().get())
+ continue;
+ aObjectNames << QString::fromStdString(aObj->data()->name());
+ }
+ aDescription = aDescription.arg(aObjectNames.join(", "));
+ SessionPtr aMgr = ModelAPI_Session::get();
+ aMgr->startOperation(aDescription.toStdString());
+ std::set<FeaturePtr>::const_iterator anIt = aRefFeatures.begin(),
+ aLast = aRefFeatures.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aRefFeature = (*anIt);
+ DocumentPtr aDoc = aRefFeature->document();
+ aDoc->removeFeature(aRefFeature);
+ }
+
+
+ foreach (ObjectPtr aObj, theList)
+ {
+ DocumentPtr aDoc = aObj->document();
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
+ if (aPart) {
+ if (aDoc == aMgr->activeDocument()) {
+ aDoc->close();
+ }
+ } else {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+ if (aFeature) {
+ aDoc->removeFeature(aFeature);
+ }
+ }
+ }
+
+ myDisplayer->updateViewer();
+ aMgr->finishOperation();
+ updateCommandStatus();
+}
+
+bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes)
+{
+ bool isFoundResultType = false;
+ foreach(ObjectPtr anObj, theObjects)
+ {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+ if (aResult.get() == NULL)
+ continue;
+
+ isFoundResultType = theTypes.find(aResult->groupName()) != theTypes.end();
+ if (isFoundResultType)
+ break;
+ }
+ return isFoundResultType;
+}
+
+//**************************************************************
+bool XGUI_Workshop::canChangeColor() 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());
+ return hasResults(aObjects, aTypes);
+}
+
+//**************************************************************
+void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
+{
+ // 1. find the initial value of the color
+ AttributeIntArrayPtr aColorAttr;
+ foreach(ObjectPtr anObj, theObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+ if (aResult.get() != NULL) {
+ aColorAttr = aResult->data()->intArray(ModelAPI_Result::COLOR_ID());
+ }
+ }
+ // there is no object with the color attribute
+ if (aColorAttr.get() == NULL || aColorAttr->size() == 0)
+ return;
+ int aRed = aColorAttr->value(0);
+ int aGreen = aColorAttr->value(1);
+ int aBlue = aColorAttr->value(2);
+
+ // 2. show the dialog to change the value
+ QDialog* aDlg = new QDialog();
+ QVBoxLayout* aLay = new QVBoxLayout(aDlg);
+
+ QtxColorButton* aColorBtn = new QtxColorButton(aDlg);
+ aColorBtn->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+
+ aLay->addWidget(aColorBtn);
+ aColorBtn->setColor(QColor(aRed, aGreen, aBlue));
+
+ QDialogButtonBox* aButtons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
+ Qt::Horizontal, aDlg);
+ connect(aButtons, SIGNAL(accepted()), aDlg, SLOT(accept()));
+ connect(aButtons, SIGNAL(rejected()), aDlg, SLOT(reject()));
+ aLay->addWidget(aButtons);
+
+ aDlg->move(QCursor::pos());
+ bool isDone = aDlg->exec() == QDialog::Accepted;
+ if (!isDone)
+ return;
+
+ QColor aColorResult = aColorBtn->color();
+ int aRedResult = aColorResult.red(),
+ aGreenResult = aColorResult.green(),
+ aBlueResult = aColorResult.blue();
+
+ if (aRedResult == aRed && aGreenResult == aGreen && aBlueResult == aBlue)
+ return;
+
+ // 3. abort the previous operation and start a new one
+ SessionPtr aMgr = ModelAPI_Session::get();
+ bool aWasOperation = aMgr->isOperation(); // keep this value
+ if (!aWasOperation) {
+ QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text();
+ aMgr->startOperation(aDescription.toStdString());
+ }
+
+ // 4. set the value to all results
+ static Events_ID EVENT_DISP = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY);
+ foreach(ObjectPtr anObj, theObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+ if (aResult.get() != NULL) {
+ aColorAttr = aResult->data()->intArray(ModelAPI_Result::COLOR_ID());
+ if (aColorAttr.get() != NULL) {
+ if (!aColorAttr->size()) {
+ aColorAttr->setSize(3);
}
- //aMgr->moduleDocument()->removeFeature(aPart->owner());
- } else {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
- if (aFeature)
- aObj->document()->removeFeature(aFeature);
+ aColorAttr->setValue(0, aRedResult);
+ aColorAttr->setValue(1, aGreenResult);
+ aColorAttr->setValue(2, aBlueResult);
+ ModelAPI_EventCreator::get()->sendUpdated(anObj, EVENT_DISP);
}
}
- myDisplayer->updateViewer();
- aMgr->finishOperation();
}
+ if (!aWasOperation)
+ aMgr->finishOperation();
+ updateCommandStatus();
}
//**************************************************************
} else
myDisplayer->display(theObj, false);
}
+
+void XGUI_Workshop::addHistoryMenu(QObject* theObject, const char* theSignal, const char* theSlot)
+{
+ XGUI_HistoryMenu* aMenu = NULL;
+ if (isSalomeMode()) {
+ QAction* anAction = qobject_cast<QAction*>(theObject);
+ if (!anAction)
+ return;
+ aMenu = new XGUI_HistoryMenu(anAction);
+ } else {
+ QToolButton* aButton = qobject_cast<QToolButton*>(theObject);
+ aMenu = new XGUI_HistoryMenu(aButton);
+ }
+ connect(this, theSignal, aMenu, SLOT(setHistory(const QList<ActionInfo>&)));
+ connect(aMenu, SIGNAL(actionSelected(int)), this, theSlot);
+}
+
+QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>& theList) const
+{
+ QList<ActionInfo> aResult;
+ std::list<std::string>::const_iterator it = theList.cbegin();
+ for (; it != theList.cend(); it++) {
+ QString anId = QString::fromStdString(*it);
+ bool isEditing = anId.endsWith(ModuleBase_Operation::EditSuffix());
+ if (isEditing) {
+ anId.chop(ModuleBase_Operation::EditSuffix().size());
+ }
+ ActionInfo anInfo = myActionsMgr->actionInfoById(anId);
+ if (isEditing) {
+ anInfo.text = anInfo.text.prepend("Modify ");
+ }
+ aResult << anInfo;
+ }
+ return aResult;
+}
