src/ModuleBase/ModuleBase_ParamSpinBox.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "ModuleBase_ParamSpinBox.h"
  22
  23 #include <QKeyEvent>
  24 #include <QLocale>
  25 #include <QRegExp>
  26 #include <QToolTip>
  27 #include <QApplication>
  28
  29 #include <QStringListModel>
  30 #include <QCompleter>
  31 #include <QAbstractItemView>
  32 #include <QShortcut>
  33
  34 #include <string>
  35 #include <iostream>
  36 #include <cfloat>
  37
  38
  39 bool isVariableSymbol(const QChar& theChar) {
  40   if (theChar.isLetterOrNumber())
  41     return true;
  42   if (theChar == '_')
  43     return true;
  44   return false;
  45 }
  46
  47 ModuleBase_ParamSpinBox::ModuleBase_ParamSpinBox(QWidget* theParent, int thePrecision)
  48   : QAbstractSpinBox(theParent),
  49   myPrecision(thePrecision),
  50   myIsEquation(false),
  51   myAcceptVariables(true),
  52   mySingleStep(1),
  53   myMinimum(DBL_MIN),
  54   myMaximum(DBL_MAX)
  55 {
  56   myCompleter = new QCompleter(this);
  57   myCompleter->setWidget(lineEdit());
  58   myCompleter->setCompletionMode(QCompleter::PopupCompletion);
  59
  60   myCompleterModel = new QStringListModel(this);
  61   myCompleter->setModel(myCompleterModel);
  62   connect(myCompleter, SIGNAL(highlighted(const QString&)),
  63     this, SLOT(insertCompletion(const QString&)));
  64
  65   QAbstractItemView* aPopup = myCompleter->popup();
  66   aPopup->installEventFilter(this);
  67
  68   //  connectSignalsAndSlots();
  69   myEnabledBaseColor = palette().color(QPalette::Active, QPalette::Base);
  70   connect(lineEdit(), SIGNAL(textChanged(const QString&)),
  71     this, SLOT(onTextChanged(const QString&)));
  72
  73   setLocale(QLocale::c());
  74
  75   myValidator = new QDoubleValidator(this);
  76   myValidator->setLocale(locale());
  77   myValidator->setRange(myMinimum, myMaximum);
  78   myValidator->setDecimals(myPrecision);
  79 }
  80
  81 void ModuleBase_ParamSpinBox::setCompletionList(QStringList& theList)
  82 {
  83   theList.removeDuplicates();
  84   theList.sort();
  85   myCompleterModel->setStringList(theList);
  86 }
  87
  88 /*!
  89  \brief Destructor.
  90  */
  91 ModuleBase_ParamSpinBox::~ModuleBase_ParamSpinBox()
  92 {
  93 }
  94
  95
  96 /*!
  97  \brief Perform \a steps increment/decrement steps.
  98
  99  Re-implemented to handle cases when Notebook variable
 100  name is specified by the user as the widget text.
 101  Otherwise, simply calls the base implementation.
 102
 103  \param steps number of increment/decrement steps
 104  */
 105 void ModuleBase_ParamSpinBox::stepBy(int steps)
 106 {
 107   if (hasVariable())
 108     return;
 109
 110   double aVal = lineEdit()->text().toDouble();
 111   aVal += steps * mySingleStep;
 112   setValue(aVal);
 113   QAbstractSpinBox::stepBy(steps);
 114 }
 115
 116 void ModuleBase_ParamSpinBox::onTextChanged(const QString& theText)
 117 {
 118   myIsEquation = hasVariable(theText);
 119   emit textChanged(theText);
 120 }
 121
 122
 123 /*!
 124  \brief This function is used to determine whether input is valid.
 125  \param str currently entered value
 126  \param pos cursor position in the string
 127  \return validating operation result
 128  */
 129 QValidator::State ModuleBase_ParamSpinBox::validate(QString& str, int& pos) const
 130 {
 131   // Trying to interpret the current input text as a numeric value
 132   if (!hasVariable(str)) {
 133     /// If decimals = 0 do not accept '.' (interpret as int)
 134     if ((myValidator->decimals() == 0) && str.endsWith('.'))
 135       return QValidator::Invalid;
 136     return myValidator->validate(str, pos);
 137   }
 138
 139   return isAcceptVariables() ? QValidator::Acceptable : QValidator::Invalid;
 140 }
 141
 142 /*!
 143  \brief This function is used to set a current value for this spinbox.
 144  \param value current value
 145
 146  The new value is ignored if the spinbox has a variable.
 147  */
 148 void ModuleBase_ParamSpinBox::setValue(double value)
 149 {
 150   myIsEquation = false;
 151   double aVal = value;
 152   if (aVal < myMinimum)
 153     aVal = myMinimum;
 154   else if (aVal > myMaximum)
 155     aVal = myMaximum;
 156   QString aText = QString::number(aVal, 'g', decimals());
 157   lineEdit()->setText(aText);
 158   emit textChanged(aText);
 159 }
 160
 161 double ModuleBase_ParamSpinBox::value() const
 162 {
 163   return lineEdit()->text().toDouble();
 164 }
 165
 166 /*!
 167  \brief This function is used to set a text for this spinbox.
 168  \param value current value
 169  */
 170 void ModuleBase_ParamSpinBox::setText(const QString& value)
 171 {
 172   myIsEquation = hasVariable(value);
 173   if (myAcceptVariables && myIsEquation) {
 174     lineEdit()->setText(value);
 175     emit textChanged(value);
 176   }
 177 }
 178
 179 /*!
 180  \brief Enables or disables variable names in the spin box.
 181  By default, variable names are enabled.
 182  \param flag If true, variable names are enabled.
 183  */
 184 void ModuleBase_ParamSpinBox::setAcceptVariables(const bool flag)
 185 {
 186   myAcceptVariables = flag;
 187   if ((!myAcceptVariables) && myIsEquation) {
 188     setValue(0);
 189   }
 190 }
 191
 192 /*!
 193  \brief Returns true if the spin box accepts variable names.
 194  */
 195 bool ModuleBase_ParamSpinBox::isAcceptVariables() const
 196 {
 197   return myAcceptVariables;
 198 }
 199
 200 bool ModuleBase_ParamSpinBox::hasVariable() const
 201 {
 202   return myIsEquation;
 203 }
 204
 205 bool ModuleBase_ParamSpinBox::hasVariable(const QString& theText) const
 206 {
 207   bool isDouble = false;
 208   QLocale::c().toDouble(theText, &isDouble);
 209   return !isDouble;
 210 }
 211
 212 void ModuleBase_ParamSpinBox::showCompletion()
 213 {
 214   myCompletePos = lineEdit()->cursorPosition();
 215   int aStart, aEnd;
 216   QString aPrefix;
 217   aPrefix = getPrefix(aStart, aEnd);
 218   if (aPrefix.length() > 0) {
 219     myCompleter->setCompletionPrefix(aPrefix);
 220     myCompleter->complete();
 221   }
 222 }
 223
 224 void ModuleBase_ParamSpinBox::keyReleaseEvent(QKeyEvent* e)
 225 {
 226   QString aText;
 227
 228   switch (e->key()) {
 229   case Qt::Key_Backspace:
 230     showCompletion();
 231     break;
 232   case Qt::Key_Return:
 233   case Qt::Key_Enter:
 234     if (myCompleter->popup()->isVisible()) {
 235       myCompleter->popup()->hide();
 236       myIsEquation = true;
 237     }
 238     emit textChanged(lineEdit()->text());
 239     break;
 240   default:
 241     aText = e->text();
 242     if (aText.length() == 1) {
 243       QChar aChar = aText.at(0);
 244       if (isVariableSymbol(aChar)) {
 245         showCompletion();
 246       }
 247     }
 248   }
 249   QAbstractSpinBox::keyReleaseEvent(e);
 250 }
 251
 252 bool ModuleBase_ParamSpinBox::eventFilter(QObject* theObj, QEvent* theEvent)
 253 {
 254   if (theEvent->type() == QEvent::KeyRelease) {
 255     keyReleaseEvent((QKeyEvent*)theEvent);
 256   }
 257   return QAbstractSpinBox::eventFilter(theObj, theEvent);
 258 }
 259
 260
 261 QString ModuleBase_ParamSpinBox::getPrefix(int& theStart, int& theEnd) const
 262 {
 263   QString aPrefix;
 264   QString aText = lineEdit()->text();
 265   theStart = theEnd = myCompletePos;
 266   const int aLen = aText.length();
 267   if (aLen > 0) {
 268     if (myCompletePos > 0) {
 269       int aLastChar = myCompletePos - 1;
 270       QChar aChar = aText.at(aLastChar);
 271       while (isVariableSymbol(aChar)) {
 272         aPrefix.prepend(aText.at(aLastChar));
 273         aLastChar--;
 274         if (aLastChar < 0)
 275           break;
 276         aChar = aText.at(aLastChar);
 277       }
 278       theStart = aLastChar + 1;
 279     }
 280     if (myCompletePos < aLen) {
 281       int aLastChar = myCompletePos;
 282       QChar aChar = aText.at(aLastChar);
 283       while (isVariableSymbol(aChar)) {
 284         aPrefix.append(aText.at(aLastChar));
 285         aLastChar++;
 286         if (aLastChar >= aLen)
 287           break;
 288         aChar = aText.at(aLastChar);
 289       }
 290       theEnd = aLastChar;
 291     }
 292   }
 293   return aPrefix;
 294 }
 295
 296
 297 void ModuleBase_ParamSpinBox::insertCompletion(const QString& theText)
 298 {
 299   QString aText = lineEdit()->text();
 300   int aStart, aEnd;
 301   QString aPrefix = getPrefix(aStart, aEnd);
 302
 303   QString aResult;
 304   int aPrefLen = aPrefix.length();
 305   if (aPrefLen == 0)
 306     aResult = aText.insert(myCompletePos, theText);
 307   else {
 308     aResult = aText.left(aStart) + theText + aText.right(aText.length() - aEnd);
 309   }
 310   lineEdit()->setText(aResult);
 311   myIsEquation = true;
 312 }
 313
 314
 315 void ModuleBase_ParamSpinBox::setValueEnabled(bool theEnable)
 316 {
 317   setReadOnly(!theEnable);
 318
 319   QPalette aPal = palette();
 320   aPal.setColor(QPalette::All, QPalette::Base,
 321     theEnable ? myEnabledBaseColor : aPal.color(QPalette::Disabled, QPalette::Base));
 322   setPalette(aPal);
 323 }