Code/Sandbox/Plugins/EditorCommon/Controls/QNumericBox.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2 #include <StdAfx.h>
   3 #include "QNumericBox.h"
   4
   5 #include <BoostPythonMacros.h>
   6
   7 #include <QLineEdit>
   8 #include <QVBoxLayout>
   9 #include <QHBoxLayout>
  10 #include <QPushButton>
  11 #include <QPainter>
  12 #include <QProxyStyle>
  13 #include <QFocusEvent>
  14 #include <QApplication>
  15 #include <QStyleOption>
  16 #include <CryIcon.h>
  17
  18 class QNumericEditProxyStyle : public QProxyStyle
  19 {
  20 public:
  21         QNumericEditProxyStyle() : m_cursorWidth(0) {}
  22         virtual ~QNumericEditProxyStyle() override {}
  23
  24         void        setCursorWidth(int width) { m_cursorWidth = width; }
  25
  26         virtual int pixelMetric(PixelMetric metric, const QStyleOption* option = 0, const QWidget* widget = 0) const
  27         {
  28                 if (metric == QStyle::PM_TextCursorWidth)
  29                 {
  30                         return m_cursorWidth;
  31                 }
  32
  33                 return QProxyStyle::pixelMetric(metric, option, widget);
  34         }
  35
  36 private:
  37         int m_cursorWidth;
  38 };
  39
  40 class QNumericEdit : public QLineEdit
  41 {
  42 public:
  43         QNumericEdit(QWidget* parent)
  44                 : QLineEdit(parent)
  45                 , m_lastCursor(-1)
  46                 , m_editMode(false)
  47                 , m_selectAllFromMouse(true)
  48                 , m_editStyle(new QNumericEditProxyStyle())
  49                 , m_mouseMoved(false)
  50         {
  51                 setStyleSheet("background-color: transparent");
  52                 setEditMode(false);
  53                 setStyle(m_editStyle);
  54                 setText("0");
  55         }
  56
  57         inline QString text() { return QLineEdit::text().replace(',', '.'); }
  58
  59         virtual ~QNumericEdit() override {}
  60
  61         virtual void mouseDoubleClickEvent(QMouseEvent* e) override
  62         {
  63                 selectAll();
  64         }
  65
  66         virtual void focusInEvent(QFocusEvent* e) override
  67         {
  68                 m_selectAllFromMouse = false;
  69                 if (e->reason() == Qt::TabFocusReason ||
  70                     e->reason() == Qt::BacktabFocusReason)
  71                 {
  72                         setEditMode(true);
  73                 }
  74
  75                 QLineEdit::focusInEvent(e);
  76         }
  77
  78         virtual void focusOutEvent(QFocusEvent* e) override
  79         {
  80                 if (e->reason() != Qt::PopupFocusReason)
  81                 {
  82                         setEditMode(false);
  83                 }
  84
  85                 QLineEdit::focusOutEvent(e);
  86         }
  87
  88         virtual void mousePressEvent(QMouseEvent* e) override
  89         {
  90                 if (!getEditMode() && e->button() == Qt::LeftButton)
  91                 {
  92                         m_mouseDownLocation = QCursor::pos();
  93                         m_mouseMoved = false;
  94                         setCursor(Qt::BlankCursor);
  95                 }
  96                 else
  97                 {
  98                         if (m_selectAllFromMouse)
  99                         {
 100                                 m_selectAllFromMouse = false;
 101                                 selectAll();
 102                         }
 103                         else
 104                         {
 105                                 QLineEdit::mousePressEvent(e);
 106                         }
 107                 }
 108         }
 109
 110         virtual void mouseMoveEvent(QMouseEvent* e) override
 111         {
 112                 if (!getEditMode() && QApplication::mouseButtons() == Qt::LeftButton)
 113                 {
 114                         QNumericBox* numbox = qobject_cast<QNumericBox*>(parentWidget());
 115                         QPoint mouse = QCursor::pos();
 116                         if (numbox && mouse != m_mouseDownLocation)
 117                         {
 118                                 m_mouseMoved = true;
 119                                 double add = 0.0;
 120                                 if (numbox->hasMinMax())
 121                                 {
 122                                         add = (numbox->maximum() - numbox->minimum()) * double((mouse.x() - m_mouseDownLocation.x())) / double(numbox->width());
 123                                 }
 124                                 else
 125                                 {
 126                                         add = numbox->singleStep() * double((mouse.x() - m_mouseDownLocation.x()));
 127                                 }
 128
 129                                 if (Qt::ControlModifier == QApplication::keyboardModifiers())
 130                                 {
 131                                         add *= 0.01;
 132                                 }
 133                                 else if (Qt::ShiftModifier == QApplication::keyboardModifiers())
 134                                 {
 135                                         add *= 100.0;
 136                                 }
 137
 138                                 numbox->setValue(numbox->value() + add);
 139                                 QCursor::setPos(m_mouseDownLocation);
 140                         }
 141                 }
 142                 else
 143                 {
 144                         QLineEdit::mouseMoveEvent(e);
 145                 }
 146         }
 147
 148         virtual void mouseReleaseEvent(QMouseEvent* e) override
 149         {
 150                 releaseMouse();
 151                 if (!getEditMode() && e->button() == Qt::LeftButton)
 152                 {
 153                         setCursor(Qt::ArrowCursor);
 154
 155                         if (!m_mouseMoved)
 156                         {
 157                                 setEditMode(true);
 158                                 selectAllFromMouse();
 159                                 QMouseEvent pe(QEvent::MouseButtonPress, e->pos(), e->button(), e->buttons(), e->modifiers());
 160                                 QMouseEvent re(QEvent::MouseButtonRelease, e->pos(), e->button(), e->buttons(), e->modifiers());
 161                                 QApplication::sendEvent(this, &pe);
 162                                 QApplication::sendEvent(this, &re);
 163                         }
 164                 }
 165                 else
 166                 {
 167                         QLineEdit::mouseReleaseEvent(e);
 168                 }
 169         }
 170
 171         virtual bool eventFilter(QObject* object, QEvent* e) override
 172         {
 173                 if (object != this && e->type() == QEvent::MouseButtonPress)
 174                 {
 175                         QWidget* widget = qobject_cast<QWidget*>(object);
 176                         if (widget && widget->parentWidget() != this)
 177                         {
 178                                 QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(e);
 179                                 QNumericBox* numbox = qobject_cast<QNumericBox*>(parentWidget());
 180                                 if (numbox && mouseEvent->buttons() == Qt::LeftButton)
 181                                 {
 182                                         QPoint numboxPoint = numbox->mapFromGlobal(widget->mapToGlobal(mouseEvent->pos()));
 183                                         QRect numboxRect = numbox->rect();
 184                                         if (!numboxRect.contains(numboxPoint))
 185                                         {
 186                                                 setEditMode(false);
 187                                         }
 188                                 }
 189                         }
 190                 }
 191
 192                 return false;
 193         }
 194
 195         void setEditMode(bool edit)
 196         {
 197                 m_editMode = edit;
 198                 m_editStyle->setCursorWidth(edit ? 1 : 0);
 199                 setCursor(edit ? Qt::IBeamCursor : Qt::ArrowCursor);
 200
 201                 QApplication::instance()->removeEventFilter(this);
 202                 if (edit)
 203                 {
 204                         QApplication::instance()->installEventFilter(this);
 205                 }
 206                 else
 207                 {
 208                         deselect();
 209                 }
 210
 211                 update();
 212         }
 213
 214         bool getEditMode()        { return m_editMode; }
 215
 216         void selectAllFromMouse() { m_selectAllFromMouse = true; }
 217
 218         void step(double multiplier)
 219         {
 220                 QByteArray expression = text().toUtf8();
 221                 int revCursor = text().length() - cursorPosition();
 222                 int cursor = stepCursor();
 223
 224                 if (-1 != cursor)
 225                 {
 226                         int digitStart = cursor;
 227                         int digitLen = 1;
 228                         bool valid = true;
 229
 230                         for (int i = 0; i < digitStart; ++i)
 231                         {
 232                                 if (' ' == text().at(i))
 233                                 {
 234                                         continue;
 235                                 }
 236
 237                                 QString strValue = text().mid(i, 1 + digitStart - i);
 238                                 double value = strValue.toDouble(&valid);
 239                                 double avalue = atof(strValue.toUtf8().constData());
 240
 241                                 if (valid && avalue == value)
 242                                 {
 243                                         digitLen = 1 + digitStart - i;
 244                                         digitStart = i;
 245                                         break;
 246                                 }
 247                         }
 248
 249                         QString numString = text().mid(digitStart, digitLen);
 250                         QString addString;
 251                         int digitEnd = digitStart + digitLen;
 252
 253                         for (QChar c : numString)
 254                         {
 255                                 addString.append(isxdigit(c.toLatin1()) ? '0' : c);
 256                         }
 257
 258                         QByteArray tmpAddStr = addString.toUtf8();
 259                         tmpAddStr[tmpAddStr.length() - 1] = '1';
 260                         addString = QString(tmpAddStr);
 261
 262                         double result = numString.toDouble();
 263                         double add = addString.toDouble();
 264
 265                         if (add < 0.0f)
 266                         {
 267                                 add = -add;
 268                         }
 269
 270                         result += add * multiplier;
 271
 272                         int decPoint = numString.indexOf('.');
 273                         int precision = numString.length() - (decPoint + 1);
 274                         QString outNumber = -1 != decPoint ? QString::number(result, 'f', precision) : QString::number(result, 'f', 0);
 275                         QString outText = text().mid(0, digitStart) + outNumber + text().mid(digitEnd);
 276                         setText(outText);
 277                         setCursorPosition(text().length() - revCursor);
 278                 }
 279         }
 280
 281         virtual void keyPressEvent(QKeyEvent* e) override
 282         {
 283                 if (e->key() == Qt::Key_Escape ||
 284                     e->key() == Qt::Key_Enter ||
 285                     e->key() == Qt::Key_Return)
 286                 {
 287                         QLineEdit::editingFinished();
 288                         if (hasFocus())
 289                         {
 290                                 selectAll();
 291                         }
 292
 293                         //Lets the keypress go to parents, i.e. the parent dialog may close on Enter/ESC
 294                         //Note that this behavior can be observed on QLineEdit
 295                         e->ignore();
 296                         return;
 297                 }
 298
 299                 if (e->key() == Qt::Key_Up ||
 300                     e->key() == Qt::Key_Down)
 301                 {
 302                         step(e->key() == Qt::Key_Up ? 1.0f : -1.0f);
 303                         QNumericBox* numbox = qobject_cast<QNumericBox*>(parentWidget());
 304                         if (numbox)
 305                         {
 306                                 numbox->valueChanged(numbox->value());
 307                         }
 308                 }
 309                 else if (getEditMode())
 310                 {
 311                         QLineEdit::keyPressEvent(e);
 312                 }
 313         }
 314
 315         int stepCursor()
 316         {
 317                 if (hasSelectedText() || !hasFocus() || !getEditMode())
 318                 {
 319                         return -1;
 320                 }
 321
 322                 int cursor = cursorPosition() - 1;
 323                 if (cursor >= 0 && cursor < text().length())
 324                 {
 325                         char currentChar = text().at(cursor).toLatin1();
 326                         if (isdigit(currentChar))
 327                         {
 328                                 return cursor;
 329                         }
 330                 }
 331                 return -1;
 332         }
 333
 334         QRect stepCursorRect(int cursor)
 335         {
 336                 int currentCursor = cursorPosition();
 337                 if (m_lastText != text() || m_lastCursor != currentCursor)
 338                 {
 339                         int start = selectionStart();
 340                         int length = selectedText().length();
 341                         setCursorPosition(cursor);
 342                         m_stepRect = cursorRect();
 343                         setCursorPosition(currentCursor);
 344                         setSelection(start, length);
 345                         m_lastText = text();
 346                         m_lastCursor = currentCursor;
 347                 }
 348                 return m_stepRect;
 349         }
 350
 351 private:
 352         inline bool isValidDigit(char c) { return isdigit(c) || '.' == c; }
 353
 354         QRect                   m_stepRect;
 355         QString                 m_lastText;
 356         int                     m_lastCursor;
 357         int                     m_editMode;
 358         QNumericEditProxyStyle* m_editStyle;
 359         bool                    m_selectAllFromMouse;
 360         bool                    m_mouseMoved;
 361         QPoint                  m_mouseDownLocation;
 362 };
 363
 364 QNumericButton::QNumericButton(QWidget* parent)
 365         : QWidget(parent)
 366         , m_spinClickTimerId(-1)
 367         , m_spinClickTimerInterval(100)
 368         , m_spinClickThresholdTimerId(-1)
 369         , m_spinClickThresholdTimerInterval(-1)
 370         , m_effectiveSpinRepeatRate(1)
 371         , m_acceleration(0)
 372         , m_accelerated(false)
 373 {
 374         setStyleSheet("background-color: transparent");
 375         setAutoFillBackground(false);
 376         setAttribute(Qt::WA_TranslucentBackground);
 377         setAttribute(Qt::WA_NoSystemBackground);
 378 }
 379
 380 void QNumericButton::paintEvent(QPaintEvent* e)
 381 {
 382         QPainter painter(this);
 383         m_icon.paint(&painter, rect());
 384 }
 385
 386 void QNumericButton::mousePressEvent(QMouseEvent* e)
 387 {
 388         reset();
 389         if (Qt::LeftButton == e->button())
 390         {
 391                 singleStep();
 392                 clicked();
 393                 m_spinClickThresholdTimerId = startTimer(m_spinClickThresholdTimerInterval);
 394         }
 395         e->accept();
 396 }
 397
 398 void QNumericButton::changeEvent(QEvent* e)
 399 {
 400         switch (e->type())
 401         {
 402         case QEvent::StyleChange:
 403                 m_spinClickTimerInterval = style()->styleHint(QStyle::SH_SpinBox_ClickAutoRepeatRate, 0, this);
 404                 m_spinClickThresholdTimerInterval = style()->styleHint(QStyle::SH_SpinBox_ClickAutoRepeatThreshold, 0, this);
 405                 reset();
 406                 break;
 407
 408         case QEvent::EnabledChange:
 409                 if (!isEnabled())
 410                 {
 411                         reset();
 412                 }
 413                 break;
 414
 415         case QEvent::ActivationChange:
 416                 if (!isActiveWindow())
 417                 {
 418                         reset();
 419                 }
 420                 break;
 421
 422         default:
 423                 break;
 424         }
 425
 426         QWidget::changeEvent(e);
 427 }
 428
 429 void QNumericButton::mouseReleaseEvent(QMouseEvent* e)
 430 {
 431         reset();
 432         e->accept();
 433
 434         if (Qt::LeftButton == e->button())
 435         {
 436                 clicked();
 437         }
 438 }
 439
 440 void QNumericButton::focusOutEvent(QFocusEvent* e)
 441 {
 442         reset();
 443         QWidget::focusOutEvent(e);
 444 }
 445
 446 void QNumericButton::timerEvent(QTimerEvent* e)
 447 {
 448         if (e->timerId() == m_spinClickThresholdTimerId)
 449         {
 450                 killTimer(m_spinClickThresholdTimerId);
 451                 m_spinClickThresholdTimerId = -1;
 452                 m_effectiveSpinRepeatRate = m_spinClickTimerInterval;
 453                 m_spinClickTimerId = startTimer(m_effectiveSpinRepeatRate);
 454                 singleStep();
 455         }
 456         else if (e->timerId() == m_spinClickTimerId)
 457         {
 458                 if (m_accelerated)
 459                 {
 460                         m_acceleration = m_acceleration + (int)(m_effectiveSpinRepeatRate * 0.05);
 461                         if (m_effectiveSpinRepeatRate - m_acceleration >= 10)
 462                         {
 463                                 killTimer(m_spinClickTimerId);
 464                                 m_spinClickTimerId = startTimer(m_effectiveSpinRepeatRate - m_acceleration);
 465                         }
 466                 }
 467                 singleStep();
 468         }
 469
 470         QWidget::timerEvent(e);
 471 }
 472
 473 void QNumericButton::reset()
 474 {
 475         if (m_spinClickTimerId != -1)
 476         {
 477                 killTimer(m_spinClickTimerId);
 478         }
 479         if (m_spinClickThresholdTimerId != -1)
 480         {
 481                 killTimer(m_spinClickThresholdTimerId);
 482         }
 483         m_spinClickTimerId = m_spinClickThresholdTimerId = -1;
 484         m_acceleration = 0;
 485 }
 486
 487 QNumericBox::QNumericBox(QWidget* parent)
 488         : QWidget(parent)
 489         , m_min(-DBL_MAX)
 490         , m_max(DBL_MAX)
 491         , m_step(0.1)
 492         , m_value(0)
 493         , m_precision(6)
 494 {
 495         m_pEdit = new QNumericEdit(this);
 496
 497         connect(m_pEdit, &QLineEdit::editingFinished, this, &QNumericBox::textEdited);
 498
 499         QHBoxLayout* pHLayout = new QHBoxLayout(this);
 500         pHLayout->addWidget(m_pEdit);
 501         pHLayout->setContentsMargins(0, 0, 0, 0);
 502         pHLayout->setSpacing(0);
 503
 504         QVBoxLayout* pVLayout = new QVBoxLayout();
 505         pHLayout->addLayout(pVLayout);
 506
 507         m_pUpButton = new QNumericButton();
 508         m_pUpButton->setMaximumSize(QSize(20, 10));
 509         m_pUpButton->setMinimumSize(QSize(20, 10));
 510         m_pUpButton->setIcon(CryIcon("icons:General/Pointer_Up_Numeric.ico"));
 511         connect(m_pUpButton, &QNumericButton::singleStep, [=]() { step(1.0); });
 512         connect(m_pUpButton, &QNumericButton::clicked, [=]() { valueSubmitted(value()); });
 513
 514         m_pDownButton = new QNumericButton();
 515         m_pDownButton->setMaximumSize(QSize(20, 10));
 516         m_pDownButton->setMinimumSize(QSize(20, 10));
 517         m_pDownButton->setIcon(CryIcon("icons:General/Pointer_Down_Numeric.ico"));
 518         connect(m_pDownButton, &QNumericButton::clicked, [=]() { step(-1.0); });
 519         connect(m_pDownButton, &QNumericButton::clicked, [=]() { valueSubmitted(value()); });
 520
 521         pVLayout->addWidget(m_pUpButton);
 522         pVLayout->addWidget(m_pDownButton);
 523         pVLayout->setContentsMargins(0, 0, 0, 0);
 524         pVLayout->setSpacing(0);
 525
 526         setLayout(pHLayout);
 527         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 528 }
 529
 530 QNumericBox::~QNumericBox()
 531 {
 532         m_pEdit->removeEventFilter(this);
 533 }
 534
 535 void QNumericBox::setRestrictToInt()
 536 {
 537         setPrecision(0);
 538         setSingleStep(1);
 539 }
 540
 541 void QNumericBox::setAlignment(Qt::Alignment alignment)
 542 {
 543         m_pEdit->setAlignment(alignment);
 544 }
 545
 546 void QNumericBox::setAccelerated(bool accelerated)
 547 {
 548         m_pUpButton->setAccelerated(accelerated);
 549         m_pDownButton->setAccelerated(accelerated);
 550 }
 551
 552 double QNumericBox::value() const
 553 {
 554         if (!GetIEditor() || !GetIEditor()->GetIPythonManager())
 555                 return 0.0;
 556
 557         if (m_pEdit->text() == "")
 558         {
 559                 return m_value;
 560         }
 561         GetIEditor()->GetIPythonManager()->Execute((QString("numeric_expression_result = ") + m_pEdit->text()).toUtf8().constData());
 562         double result = (double)GetIEditor()->GetIPythonManager()->GetAsFloat("numeric_expression_result");
 563         return result;
 564 }
 565
 566 double QNumericBox::getSliderPosition() const
 567 {
 568         if (!hasMinMax())
 569         {
 570                 return 0.0;
 571         }
 572
 573         if (m_pEdit->getEditMode())
 574         {
 575                 return 0.0;
 576         }
 577
 578         return clamp_tpl(double(value() - m_min) / (m_max - m_min), 0.0, 1.0);
 579 }
 580
 581 void QNumericBox::setValue(double value)
 582 {
 583         value = clamp_tpl(value, m_min, m_max);
 584
 585         QString outText = QString::number(value, 'f', m_precision);
 586         int revCursor = m_pEdit->text().length() - m_pEdit->cursorPosition();
 587         int decPoint = outText.lastIndexOf('.');
 588
 589         if (-1 != decPoint)
 590         {
 591                 for (int i = outText.length() - 1; i > decPoint; --i)
 592                 {
 593                         if ('0' == outText.at(i))
 594                         {
 595                                 outText.remove(i, 1);
 596                         }
 597                         else
 598                         {
 599                                 break;
 600                         }
 601                 }
 602         }
 603
 604         if ('.' == outText.at(outText.length() - 1))
 605         {
 606                 outText.remove(outText.length() - 1, 1);
 607         }
 608
 609         m_value = value;
 610         m_pEdit->setText(outText);
 611         m_pEdit->setCursorPosition(m_pEdit->text().length() - revCursor);
 612
 613         valueChanged(value);
 614 }
 615
 616 void QNumericBox::setPrecision(int precision)
 617 {
 618         if (m_precision != precision)
 619         {
 620                 m_precision = precision;
 621                 setValue(value());
 622         }
 623 }
 624
 625 void QNumericBox::step(double multiplier)
 626 {
 627         if (Qt::ControlModifier == QApplication::keyboardModifiers())
 628         {
 629                 multiplier *= 0.01;
 630         }
 631         else if (Qt::ShiftModifier == QApplication::keyboardModifiers())
 632         {
 633                 multiplier *= 100.0;
 634         }
 635
 636         setValue(value() + m_step * multiplier);
 637 }
 638
 639 void QNumericBox::textEdited()
 640 {
 641         double val = value();
 642         setValue(val);
 643         valueSubmitted(val);
 644 }
 645
 646 bool QNumericBox::hasMinMax() const
 647 {
 648         return -DBL_MAX != m_min && DBL_MAX != m_max;
 649 }
 650
 651 void QNumericBox::paintEvent(QPaintEvent* e)
 652 {
 653         QPainter painter(this);
 654         QStyleOptionFrameV2 option;
 655         option.state = QStyle::State_Sunken;
 656         option.lineWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, &option, 0);
 657         option.midLineWidth = 0;
 658         option.features = QStyleOptionFrameV2::None;
 659         if (m_pEdit->isEnabled())
 660         {
 661                 option.state |= QStyle::State_Enabled;
 662         }
 663         option.rect = rect();
 664         option.palette = m_pEdit->palette();
 665         option.fontMetrics = m_pEdit->fontMetrics();
 666
 667         painter.setPen(QPen(m_pEdit->palette().color(QPalette::WindowText)));
 668         painter.setBrush(QBrush(m_pEdit->palette().color(QPalette::Base)));
 669
 670         static QLineEdit s_lineEdit;
 671         s_lineEdit.style()->drawPrimitive(QStyle::PE_PanelLineEdit, &option, &painter, &s_lineEdit);
 672
 673         double sliderPos = getSliderPosition();
 674         if (sliderPos != 0.0)
 675         {
 676                 QRect r = rect();
 677                 QRect sliderOverlayRect(r.left(), r.top(), int(r.width() * sliderPos), r.height());
 678                 QColor sliderOverlayColor = m_sliderColor;
 679
 680                 painter.setBrush(QBrush(sliderOverlayColor));
 681                 painter.setPen(Qt::NoPen);
 682                 painter.drawRoundedRect(sliderOverlayRect, 2, 2);
 683         }
 684
 685         m_pDownButton->update();
 686         m_pUpButton->update();
 687 }
 688
 689 void QNumericBox::setEditMode(bool edit)
 690 {
 691         m_pEdit->setFocus(Qt::TabFocusReason);
 692 }
 693
 694 void QNumericBox::alignText()
 695 {
 696         m_pEdit->home(false);
 697 }
 698
 699 void QNumericBox::setText(const QString& text)
 700 {
 701         m_pEdit->setText(text);
 702 }
 703
 704 QString QNumericBox::text() const
 705 {
 706         return m_pEdit->text();
 707 }
 708
 709 void QNumericBox::setPlaceholderText(const QString& text)
 710 {
 711         m_pEdit->setPlaceholderText(text);
 712 }
 713
 714 void QNumericBox::grabFocus()
 715 {
 716         m_pEdit->setFocus();
 717 }
 718
 719 void QNumericBox::wheelEvent(QWheelEvent* e)
 720 {
 721         step(sgn(e->delta()));
 722 }
 723
 724 void QNumericBox::showEvent(QShowEvent* e)
 725 {
 726         QWidget::showEvent(e);
 727         shown();
 728 }
 729
 730 void QNumericBox::resizeEvent(QResizeEvent* event)
 731 {
 732         QWidget::resizeEvent(event);
 733
 734         //Hide the buttons if the width is less than 8 characters
 735         const bool buttonsVisible = event->size().width() > m_pEdit->fontMetrics().averageCharWidth() * 10;
 736         m_pUpButton->setVisible(buttonsVisible);
 737         m_pDownButton->setVisible(buttonsVisible);
 738 }
 739
 740 void QNumericBox::focusInEvent(QFocusEvent* e)
 741 {
 742         m_pEdit->setFocus(e->reason());
 743 }