*/
ModuleBase_DoubleSpinBox::ModuleBase_DoubleSpinBox(QWidget* theParent, int thePrecision)
: QDoubleSpinBox(theParent),
- myCleared(false),
- myIsEmitKeyPressEvent(false)
+ myCleared(false)
{
setLocale(ModuleBase_Tools::doubleLocale());
return res;
}
-void ModuleBase_DoubleSpinBox::keyPressEvent(QKeyEvent* theEvent)
-{
- switch (theEvent->key()) {
- case Qt::Key_Enter:
- case Qt::Key_Return: {
- // do not react to the Enter key, the property panel processes it
- if (!myIsEmitKeyPressEvent)
- return;
- }
- break;
- default:
- break;
- }
- QDoubleSpinBox::keyPressEvent(theEvent);
-}
-
-void ModuleBase_DoubleSpinBox::keyReleaseEvent(QKeyEvent* theEvent)
-{
- switch (theEvent->key()) {
- case Qt::Key_Enter:
- case Qt::Key_Return: {
- // the enter has already been processed when key is pressed,
- // key release should not be processed in operation manager
- if (myIsEmitKeyPressEvent) {
- theEvent->accept();
- emit enterReleased();
- return;
- }
- }
- break;
- default:
- break;
- }
- QDoubleSpinBox::keyReleaseEvent(theEvent);
-}
-
/*!
\brief Perform \a steps increment/decrement steps.
myCleared = false;
}
-bool ModuleBase_DoubleSpinBox::enableKeyPressEvent(const bool& theEnable)
-{
- bool aPreviousValue = myIsEmitKeyPressEvent;
- myIsEmitKeyPressEvent = theEnable;
-
- return aPreviousValue;
-}
-
void ModuleBase_DoubleSpinBox::setValueEnabled(const bool& theEnable)
{
setReadOnly(!theEnable);
/// Validate current value
virtual QValidator::State validate(QString&, int&) const;
- /// Change enable/disable internal state to emit key press event
- /// \param theEnable if true, the signal is emitted
- /// \return the previous value
- bool enableKeyPressEvent(const bool& theEnable);
-
/// Imitation of disable control value. If theEnable is false, the control becomes
/// read only and base color is disabled.
void setValueEnabled(const bool& theEnable);
-signals:
- /// The signal about key release on the control, that corresponds to the attribute
- void enterReleased();
-
protected slots:
/// Called on text changed
virtual void onTextChanged(const QString&);
protected:
/// Removes extra trailing zero symbols
QString removeTrailingZeroes(const QString&) const;
- /// Called on key press event
- virtual void keyReleaseEvent(QKeyEvent* theEvent);
-
- /// Called on key press event
- virtual void keyPressEvent(QKeyEvent* theEvent);
private:
// boolen flag whether the key event is emitted. The default value is false
// Author: Natalia ERMOLAEVA
#include "ModuleBase_ModelWidget.h"
+#include "ModuleBase_IPropertyPanel.h"
#include "ModuleBase_ViewerPrs.h"
#include "ModuleBase_Tools.h"
#include "ModuleBase_WidgetValidator.h"
QFocusEvent* aFocusEvent = dynamic_cast<QFocusEvent*>(theEvent);
bool isWinFocus = aFocusEvent->reason() == Qt::ActiveWindowFocusReason;
#endif
- if (getControls().contains(aWidget)) {
- emit focusInWidget(this);
+ Qt::FocusReason aReason = aFocusEvent->reason();
+ bool aMouseOrKey = aReason == Qt::MouseFocusReason ||
+ /*aReason == Qt::TabFocusReason ||
+ //aReason == Qt::BacktabFocusReason ||*/
+ aReason == Qt::OtherFocusReason; // to process widget->setFocus()
+ if (aMouseOrKey && getControls().contains(aWidget)) {
+ //if (getControls().contains(aWidget)) {
+ emitFocusInWidget();
}
}
else if (theEvent->type() == QEvent::FocusOut) {
setValueState(ModifiedInPP);
}
+//**************************************************************
QString ModuleBase_ModelWidget::translate(const std::string& theStr) const
{
return ModuleBase_Tools::translate(context(), theStr);
}
+
+//**************************************************************
+ModuleBase_ModelWidget* ModuleBase_ModelWidget::findModelWidget(ModuleBase_IPropertyPanel* theProp,
+ QWidget* theWidget)
+{
+ ModuleBase_ModelWidget* aModelWidget;
+ QObject* aParent = theWidget->parent();
+ while (aParent) {
+ aModelWidget = qobject_cast<ModuleBase_ModelWidget*>(aParent);
+ if (aModelWidget)
+ break;
+ aParent = aParent->parent();
+ }
+ return aModelWidget;
+}
class Config_WidgetAPI;
class Events_InfoMessage;
+class ModuleBase_IPropertyPanel;
class ModuleBase_IWorkshop;
class ModuleBase_ViewerPrs;
class ModuleBase_WidgetValidator;
/// Translate passed string with widget context()
virtual QString translate(const std::string& theStr) const;
+ /// Emit focus in widget to set this control as active in propety panel
+ void emitFocusInWidget() { emit focusInWidget(this); }
+
+ /// Finds model widget parent of the given sub widget
+ /// \param theWidget a candidate to be a child of the model widget
+ /// \param theProp a property panel instance
+ /// \return a model widget or NULL
+ static ModuleBase_ModelWidget* findModelWidget(ModuleBase_IPropertyPanel* theProp,
+ QWidget* theWidget);
signals:
/// The signal about widget values are to be changed
void beforeValuesChanged();
ModuleBase_WidgetEditor::ModuleBase_WidgetEditor(QWidget* theParent,
const Config_WidgetAPI* theData)
: ModuleBase_WidgetDoubleValue(theParent, theData),
- myXPosition(-1), myYPosition(-1)
+ myXPosition(-1), myYPosition(-1), myEditorDialog(0)
{
}
{
bool isValueAccepted = false;
- QDialog aDlg(QApplication::desktop(), Qt::FramelessWindowHint);
- QHBoxLayout* aLay = new QHBoxLayout(&aDlg);
- aLay->setContentsMargins(2, 2, 2, 2);
+ myEditorDialog = new QDialog(QApplication::desktop(), Qt::FramelessWindowHint);
- ModuleBase_ParamSpinBox* anEditor = new ModuleBase_ParamSpinBox(&aDlg);
- anEditor->enableKeyPressEvent(true);
+ QHBoxLayout* aLay = new QHBoxLayout(myEditorDialog);
+ aLay->setContentsMargins(2, 2, 2, 2);
+ ModuleBase_ParamSpinBox* anEditor = new ModuleBase_ParamSpinBox(myEditorDialog);
anEditor->setMinimum(0);
anEditor->setMaximum(DBL_MAX);
if (outText.isEmpty())
ModuleBase_Tools::setFocus(anEditor, "ModuleBase_WidgetEditor::editedValue");
anEditor->selectAll();
- QObject::connect(anEditor, SIGNAL(enterReleased()), &aDlg, SLOT(accept()));
QPoint aPoint = QCursor::pos();
if (myXPosition >= 0 && myYPosition >= 0)
aPoint = QPoint(myXPosition, myYPosition);
- aDlg.move(aPoint);
- isValueAccepted = aDlg.exec() == QDialog::Accepted;
+ myEditorDialog->move(aPoint);
+ isValueAccepted = myEditorDialog->exec() == QDialog::Accepted;
if (isValueAccepted) {
outText = anEditor->text();
bool isDouble;
outText = ""; // return empty string, if it's can be converted to a double
}
}
+ delete myEditorDialog;
+ myEditorDialog = 0;
return isValueAccepted;
}
// in the property panel before the mouse leave event happens in the viewer. The module
// ask an active widget and change the feature visualization if the widget is not the current one.
if (theSendSignals)
- emit focusInWidget(this);
+ emitFocusInWidget();
// nds: it seems, that the envents processing is not necessary anymore
// White while all events will be processed
myXPosition = theX;
myYPosition = theY;
}
+
+bool ModuleBase_WidgetEditor::processEnter()
+{
+ if (myEditorDialog) {
+ myEditorDialog->accept();
+ return true;
+ }
+
+ return ModuleBase_WidgetDoubleValue::processEnter();
+}
#include <QStringList>
class ModelAPI_Feature;
+class QDialog;
class QLineEdit;
/**\class ModuleBase_WidgetEditor
/// \param theY the Y coordinate
void setCursorPosition(const int theX, const int theY);
+ /// Returns true if the event is processed.
+ virtual bool processEnter();
+
private:
/// Show editor
/// \param theOutValue a result value
QStringList myFeatureKinds;
int myXPosition, myYPosition;
+
+ QDialog* myEditorDialog;
};
#endif
myPreviousFeature = FeaturePtr();
anActiveWidget = module()->activeWidget();
- aCurrentFeature = anActiveWidget->feature();
aProcessed = true;
- if (anActiveWidget->attributeID() == anAttributeOnStart) {
+ if (anActiveWidget && anActiveWidget->attributeID() == anAttributeOnStart) {
// it was not deactivated by preselection processing
aPanel->activateNextWidget(anActiveWidget);
}
if (aPreviousAttributeWidget) {
if (!aPreviousAttributeWidget->isViewerSelector()) {
aPreviousAttributeWidget->focusTo();
+ aPreviousAttributeWidget->emitFocusInWidget();
aPreviousAttributeWidget->selectContent();
}
else {
case AbortAll: {
aResult = ModuleBase_Tools::createAction(QIcon(":pictures/button_cancel.png"), "Cancel",
aParent);
- if (theId == Abort) {
- aResult->setShortcut(QKeySequence(Qt::Key_Escape));
- }
}
break;
case Help: {
bool isAccepted = false;
if (myIsActive && theEvent->type() == QEvent::KeyRelease) {
QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
- if(aKeyEvent) {
+ if (aKeyEvent) {
switch (aKeyEvent->key()) {
- case Qt::Key_Delete: {
+ case Qt::Key_Delete:
isAccepted = myOperationMgr->onProcessDelete(theObject);
- }
+ break;
+ default:
+ myOperationMgr->onKeyReleased(theObject, aKeyEvent);
+ isAccepted = true;
+ break;
}
}
}
return myOperations.at(idx - 1);
}
-bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent)
-{
- bool isAccepted = false;
- if (theEvent->type() == QEvent::KeyRelease) {
- QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
- if(aKeyEvent)
- isAccepted = onKeyReleased(theObject, aKeyEvent);
- }
- if (!isAccepted)
- isAccepted = QObject::eventFilter(theObject, theEvent);
-
- return isAccepted;
-}
-
bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
{
if (hasOperation())
ModuleBase_Operation* anOperation = currentOperation();
bool isAccepted = false;
switch (theEvent->key()) {
+ case Qt::Key_Escape: {
+ ModuleBase_Operation* aOperation = currentOperation();
+ if (aOperation) {
+ onAbortOperation();
+ isAccepted = true;
+ }
+ }
+ break;
+ case Qt::Key_Tab:
+ case Qt::Key_Backtab:
+ {
+ ModuleBase_Operation* aOperation = currentOperation();
+ if (aOperation) {
+ ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
+ if (aPanel) { // check for case when the operation is started but property panel is not filled
+ XGUI_PropertyPanel* aPP = dynamic_cast<XGUI_PropertyPanel*>(aPanel);
+ aPP->focusNextPrevChild_(theEvent->key() == Qt::Key_Tab);
+ isAccepted = true;
+ }
+ }
+ }
+ break;
case Qt::Key_Return:
case Qt::Key_Enter: {
isAccepted = onProcessEnter(theObject);
if (!aOperation)
return isAccepted;
ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
+ // the next code is obsolete as we want to process Enter in property panel always
// only property panel enter is processed in order to do not process enter in application dialogs
- bool isPPChild = isChildObject(theObject, aPanel);
- if (!isPPChild)
- return isAccepted;
+ //bool isPPChild = isChildObject(theObject, aPanel);
+ //if (!isPPChild)
+ // return isAccepted;
ModuleBase_ModelWidget* anActiveWgt = aPanel->activeWidget();
bool isAborted = false;
/// else, or if there is no parent - returns NULL
ModuleBase_Operation* previousOperation(ModuleBase_Operation* theOperation) const;
- /// Redefinition of virtual function
- /// \param theObject a sender of the event
- /// \param theEvent the event
- virtual bool eventFilter(QObject *theObject, QEvent *theEvent);
-
/// Start the operation and append it to the stack of operations
/// \param theOperation the started operation
/// \return the state whether the current operation is started
QList<ModuleBase_ModelWidget*>::const_iterator anIt = myWidgets.begin(), aLast = myWidgets.end();
bool isFoundWidget = false;
- ModuleBase_Tools::activateWindow(this, "XGUI_PropertyPanel::activateNextWidget()");
+ //ModuleBase_Tools::activateWindow(this, "XGUI_PropertyPanel::activateNextWidget()");
for (; anIt != aLast; anIt++) {
ModuleBase_ModelWidget* aCurrentWidget = *anIt;
if (isFoundWidget || !theWidget) {
continue; // do not set focus if it can not be accepted, case: optional choice
if (aCurrentWidget->focusTo()) {
+ aCurrentWidget->emitFocusInWidget();
return;
}
}
#endif
}
-bool XGUI_PropertyPanel::focusNextPrevChild(bool theIsNext)
+bool XGUI_PropertyPanel::focusNextPrevChild_(bool theIsNext)
{
// it wraps the Tabs clicking to follow in the chain:
// controls, last control, Apply, Cancel, first control, controls
qDebug(anInfo.toStdString().c_str());
}
#endif
+ ModuleBase_ModelWidget* aFocusMWidget = ModuleBase_ModelWidget::findModelWidget(this,
+ aFocusWidget);
+ if (aFocusMWidget)
+ aFocusMWidget->setHighlighted(false);
QWidget* aNewFocusWidget = 0;
if (aFocusWidget) {
}
if (aNewFocusWidget) {
if (myActiveWidget) {
- myActiveWidget->getControls();
bool isFirstControl = !theIsNext;
QWidget* aLastFocusControl = myActiveWidget->getControlAcceptingFocus(isFirstControl);
if (aFocusWidget == aLastFocusControl) {
//ModuleBase_Tools::setFocus(aNewFocusWidget, "XGUI_PropertyPanel::focusNextPrevChild()");
aNewFocusWidget->setFocus(theIsNext ? Qt::TabFocusReason : Qt::BacktabFocusReason);
+
+ ModuleBase_ModelWidget* aNewFocusMWidget = ModuleBase_ModelWidget::findModelWidget(this,
+ aNewFocusWidget);
+ if (aNewFocusMWidget)
+ aNewFocusMWidget->emitFocusInWidget();
isChangedFocus = true;
}
return isChangedFocus;
/// Makes the widget active, deactivate the previous, activate and hightlight the given one
/// \param theWidget a widget
bool setActiveWidget(ModuleBase_ModelWidget* theWidget);
-
+public:
/// The parent method that processes the "Tab"/"SHIF + Tab" keyboard events
/// Emits a signal about focus change
/// If theIsNext is true, this function searches forward, if next is false, it searches backward.
- virtual bool focusNextPrevChild(bool theIsNext);
-
+ virtual bool focusNextPrevChild_(bool theIsNext);
+protected:
+ virtual bool focusNextPrevChild(bool theIsNext) { return true; }
/// Activate the next widget in the property panel
/// \param theWidget a widget. The next widget should be activated
/// \param isCheckVisibility flag whether the next widget visibility is checked
// 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::activateWindow(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
ModuleBase_Tools::setFocus(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
}
// set the focus on it. As a result, shortcuts of the application, like
// are processed by this console. For example Undo actions.
// It is possible that this code is to be moved to SHAPER package
- QMainWindow* aDesktop = desktop();
- ModuleBase_Tools::activateWindow(aDesktop, "XGUI_Workshop::hidePropertyPanel()");
- ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::showPropertyPanel()");
+ //QMainWindow* aDesktop = desktop();
+ //ModuleBase_Tools::activateWindow(aDesktop, "XGUI_Workshop::hidePropertyPanel()");
+ //ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::showPropertyPanel()");
}
//******************************************************
