src/ModuleBase/ModuleBase_WidgetExprEditor.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 /*
   4  * ModuleBase_WidgetExprEditor.cpp
   5  *
   6  *  Created on: Aug 28, 2014
   7  *      Author: sbh
   8  */
   9
  10 #include <ModuleBase_WidgetExprEditor.h>
  11 #include <ModuleBase_Tools.h>
  12
  13 #include <ModelAPI_Data.h>
  14 #include <ModelAPI_Object.h>
  15 #include <ModelAPI_Validator.h>
  16 #include <ModelAPI_ResultParameter.h>
  17 #include <ModelAPI_AttributeString.h>
  18 #include <ModelAPI_AttributeDouble.h>
  19
  20 #include <Config_WidgetAPI.h>
  21
  22 #include <QVBoxLayout>
  23 #include <QLabel>
  24 #include <QLineEdit>
  25 #include <QObject>
  26 #include <QString>
  27 #include <QStringListModel>
  28 #include <QCompleter>
  29 #include <QSize>
  30 #include <QShortcut>
  31 #include <QScrollBar>
  32 #include <QFontMetrics>
  33 #include <QPainter>
  34
  35 #include <memory>
  36 #include <string>
  37
  38 ExpressionEditor::ExpressionEditor(QWidget* theParent)
  39 : QPlainTextEdit(theParent), myCompletedAndSelected(false), myIsModified(false)
  40 {
  41   myCompleter = new QCompleter(this);
  42   myCompleter->setWidget(this);
  43   myCompleter->setCompletionMode(QCompleter::PopupCompletion);
  44
  45   myCompleterModel = new QStringListModel(this);
  46   myCompleter->setModel(myCompleterModel);
  47   // Use sorted model to accelerate completion (QCompleter will use binary search)
  48   myCompleter->setModelSorting(QCompleter::CaseInsensitivelySortedModel);
  49   myCompleter->setCaseSensitivity(Qt::CaseInsensitive);
  50
  51   connect(myCompleter, SIGNAL(activated(const QString&)),
  52           this,        SLOT(insertCompletion(const QString&)));
  53   (void) new QShortcut(QKeySequence(tr("Ctrl+Space", "Complete")),
  54                        this, SLOT(performCompletion()));
  55
  56   connect(this, SIGNAL(textChanged()), this, SLOT(onTextChanged()));
  57
  58   setTabChangesFocus(true);
  59 }
  60
  61 ExpressionEditor::~ExpressionEditor()
  62 {
  63
  64 }
  65
  66 void ExpressionEditor::setCompletionList(QStringList& theList)
  67 {
  68   theList.sort();
  69   theList.removeDuplicates();
  70   myCompleterModel->setStringList(theList);
  71 }
  72
  73 void ExpressionEditor::insertCompletion(const QString& theCompletion, bool isSingleWord)
  74 {
  75   QTextCursor aCursor = textCursor();
  76   int numberOfCharsToComplete = theCompletion.length() -
  77       myCompleter->completionPrefix().length();
  78   int insertionPosition = aCursor.position();
  79   aCursor.insertText(theCompletion.right(numberOfCharsToComplete));
  80   if (isSingleWord) {
  81     aCursor.setPosition(insertionPosition);
  82     aCursor.movePosition(QTextCursor::EndOfWord, QTextCursor::KeepAnchor);
  83     myCompletedAndSelected = true;
  84   }
  85   setTextCursor(aCursor);
  86 }
  87
  88 void ExpressionEditor::performCompletion()
  89 {
  90   QTextCursor aCursor = textCursor();
  91   aCursor.select(QTextCursor::WordUnderCursor);
  92   const QString aPrefix = aCursor.selectedText();
  93   if (!aPrefix.isEmpty() && aPrefix.at(aPrefix.length() - 1).isLetter()) {
  94     performCompletion(aPrefix);
  95   }
  96 }
  97
  98 void ExpressionEditor::performCompletion(const QString& theCompletionPrefix)
  99 {
 100   //populate model?
 101   if (theCompletionPrefix != myCompleter->completionPrefix()) {
 102     myCompleter->setCompletionPrefix(theCompletionPrefix);
 103     myCompleter->popup()->setCurrentIndex(myCompleter->completionModel()->index(0, 0));
 104   }
 105   if (myCompleter->completionCount() == 1) {
 106     insertCompletion(myCompleter->currentCompletion(), true);
 107   } else {
 108     QRect aRect = cursorRect();
 109     aRect.setWidth(myCompleter->popup()->sizeHintForColumn(0)
 110                   + myCompleter->popup()->verticalScrollBar()->sizeHint().width());
 111     myCompleter->complete(aRect);
 112   }
 113 }
 114
 115 void ExpressionEditor::keyPressEvent(QKeyEvent* theEvent)
 116 {
 117   bool anIsModified = myIsModified;
 118
 119   if (myCompletedAndSelected && handledCompletedAndSelected(theEvent))
 120     return;
 121   myCompletedAndSelected = false;
 122   if (myCompleter->popup()->isVisible()) {
 123     switch (theEvent->key()) {
 124       case Qt::Key_Up:
 125       case Qt::Key_Down:
 126       case Qt::Key_Escape:
 127       case Qt::Key_Enter:
 128       case Qt::Key_Return:
 129         theEvent->ignore();
 130       return;
 131       default:
 132         myCompleter->popup()->hide();
 133         break;
 134     }
 135   }
 136   else {
 137     switch (theEvent->key()) {
 138       case Qt::Key_Enter:
 139       case Qt::Key_Return:
 140         // do not react to the Enter key, the property panel processes it
 141         return;
 142       break;
 143       default:
 144         break;
 145     }
 146   }
 147   QPlainTextEdit::keyPressEvent(theEvent);
 148 }
 149
 150 bool ExpressionEditor::handledCompletedAndSelected(QKeyEvent* theEvent)
 151 {
 152   myCompletedAndSelected = false;
 153   QTextCursor aCursor = textCursor();
 154   switch (theEvent->key()) {
 155     case Qt::Key_Enter:
 156     case Qt::Key_Return: aCursor.clearSelection(); break;
 157     case Qt::Key_Escape: aCursor.removeSelectedText(); break;
 158     default: return false;
 159   }
 160   setTextCursor(aCursor);
 161   theEvent->accept();
 162   return true;
 163 }
 164
 165 void ExpressionEditor::setPlaceHolderText( const QString& thePlaceHolderText )
 166 {
 167   myPlaceHolderText = thePlaceHolderText;
 168 }
 169
 170 QString ExpressionEditor::placeHolderText() const
 171 {
 172   return myPlaceHolderText;
 173 }
 174
 175 bool ExpressionEditor::isModified() const
 176 {
 177   return myIsModified;
 178 }
 179
 180 void ExpressionEditor::clearModified()
 181 {
 182   myIsModified = false;
 183 }
 184
 185 void ExpressionEditor::paintEvent( QPaintEvent* theEvent )
 186 {
 187   QPlainTextEdit::paintEvent( theEvent );
 188
 189   if( toPlainText().isEmpty() )
 190   {
 191     QPainter aPainter( viewport() );
 192     QFontMetrics aFontMetrics = fontMetrics();
 193
 194     QPointF offset(contentOffset());
 195     QRect r = rect();
 196     int m = (int)document()->documentMargin();
 197     QRect lineRect( r.x() + m + offset.x(), offset.y(),
 198                     r.width() - 2*m, aFontMetrics.height() );
 199
 200     Qt::Alignment va = QStyle::visualAlignment( layoutDirection(), Qt::AlignLeft );
 201     int minLB = qMax( 0, -aFontMetrics.minLeftBearing() );
 202
 203     QColor aColor = palette().text().color();
 204     aColor.setAlpha( 128 );
 205     QPen anOldpen = aPainter.pen();
 206     aPainter.setPen( aColor );
 207     lineRect.adjust(minLB, 0, 0, 0);
 208     QString elidedText = aFontMetrics.elidedText( myPlaceHolderText, Qt::ElideRight, lineRect.width() );
 209     aPainter.drawText( lineRect, va, elidedText );
 210     aPainter.setPen( anOldpen );
 211   }
 212 }
 213
 214 bool ExpressionEditor::focusNextPrevChild(bool theIsNext)
 215 {
 216   if (myIsModified)
 217     emit editingFinished();
 218   emit valueStored();
 219   emit focusNextPrev();
 220   return QPlainTextEdit::focusNextPrevChild(theIsNext);
 221 }
 222
 223 void ExpressionEditor::onTextChanged()
 224 {
 225   myIsModified = true;
 226   emit valueModified();
 227 }
 228
 229
 230 ModuleBase_WidgetExprEditor::ModuleBase_WidgetExprEditor( QWidget* theParent,
 231                                                           const Config_WidgetAPI* theData,
 232                                                           const std::string& theParentId,
 233                                                           const std::string& thePlaceHolder )
 234     : ModuleBase_ModelWidget(theParent, theData, theParentId)
 235 {
 236   QVBoxLayout* aMainLay = new QVBoxLayout(this);
 237   ModuleBase_Tools::adjustMargins(aMainLay);
 238
 239   myResultLabel = new QLabel(this);
 240   myResultLabel->setWordWrap(true);
 241   QFontMetrics fm(myResultLabel->font());
 242   myResultLabel->setMinimumHeight(fm.height() * 2); // set 2 line height as minimum
 243   myResultLabel->setAlignment(Qt::AlignLeft|Qt::AlignBottom);
 244   aMainLay->addWidget(myResultLabel);
 245   myEditor = new ExpressionEditor(this);
 246   myEditor->setMinimumHeight(20);
 247   myEditor->setPlaceHolderText( QString::fromStdString( thePlaceHolder ) );
 248   aMainLay->addWidget(myEditor);
 249   this->setLayout(aMainLay);
 250
 251   connect(myEditor, SIGNAL(valueModified()), this, SIGNAL(valuesModified()));
 252   //connect(myEditor, SIGNAL(editingFinished()), this, SLOT(onTextChanged()));
 253   connect(myEditor, SIGNAL(valueStored()), this, SLOT(onTextChanged()));
 254   connect(myEditor, SIGNAL(focusNextPrev()), this, SIGNAL(focusNextPrev()));
 255 }
 256
 257 ModuleBase_WidgetExprEditor::~ModuleBase_WidgetExprEditor()
 258 {
 259 }
 260
 261 bool ModuleBase_WidgetExprEditor::storeValueCustom() const
 262 {
 263   // A rare case when plugin was not loaded.
 264   if(!myFeature)
 265     return false;
 266   DataPtr aData = myFeature->data();
 267   AttributeStringPtr aStringAttr = aData->string(attributeID());
 268   QString aWidgetValue = myEditor->toPlainText();
 269   aStringAttr->setValue(aWidgetValue.toStdString());
 270   updateObject(myFeature);
 271
 272   // Try to get the value
 273   QString aStateMsg;
 274   std::string anErrorMessage = myFeature->string("ExpressionError")->value();
 275   if (anErrorMessage.empty()) {
 276     ResultParameterPtr aParam =
 277       std::dynamic_pointer_cast<ModelAPI_ResultParameter>(myFeature->firstResult());
 278     if(aParam.get()) {
 279       AttributeDoublePtr aValueAttr =
 280         aParam->data()->real(ModelAPI_ResultParameter::VALUE());
 281       if (aValueAttr.get()) {
 282         double aValue = aValueAttr->value();
 283         aStateMsg = "Result: " + QString::number(aValue);
 284       }
 285     }
 286   } else {
 287     aStateMsg = "Error: " + QString::fromStdString(anErrorMessage);
 288   }
 289   myResultLabel->setText(aStateMsg);
 290   return true;
 291 }
 292
 293 bool ModuleBase_WidgetExprEditor::restoreValueCustom()
 294 {
 295   // A rare case when plugin was not loaded.
 296   if(!myFeature)
 297     return false;
 298   DataPtr aData = myFeature->data();
 299   AttributeStringPtr aStringAttr = aData->string(attributeID());
 300
 301   bool isBlocked = myEditor->blockSignals(true);
 302   QTextCursor aCursor = myEditor->textCursor();
 303   int pos = aCursor.position();
 304   std::string aRestoredStr = aStringAttr->value();
 305   myEditor->setPlainText(QString::fromStdString(aRestoredStr));
 306   aCursor.setPosition(pos);
 307   myEditor->setTextCursor(aCursor);
 308   myEditor->blockSignals(isBlocked);
 309
 310   return true;
 311 }
 312
 313 QList<QWidget*> ModuleBase_WidgetExprEditor::getControls() const
 314 {
 315   QList<QWidget*> result;
 316   result << myEditor;
 317   return result;
 318 }
 319
 320 bool ModuleBase_WidgetExprEditor::processEnter()
 321 {
 322   bool isModified = myEditor->isModified();
 323   if (isModified) {
 324     emit valuesChanged();
 325     myEditor->clearModified();
 326     myEditor->selectAll();
 327   }
 328   return isModified;
 329 }
 330
 331 void ModuleBase_WidgetExprEditor::onTextChanged()
 332 {
 333   emit valuesChanged();
 334 }