MLDoubleSpinBox.qml

Go to the documentation of this file.

/*
  MLDoubleSpinBox
  https://github.com/mpaperno/maxLibQt

  COPYRIGHT: (c)2018 Maxim Paperno; All Right Reserved.
  Contact: http://www.WorldDesign.com/contact

  LICENSE:

  Commercial License Usage
  Licensees holding valid commercial licenses may use this file in
  accordance with the terms contained in a written agreement between
  you and the copyright holder.

  GNU General Public License Usage
  Alternatively, this file may be used under the terms of the GNU
  General Public License as published by the Free Software Foundation,
  either version 3 of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  A copy of the GNU General Public License is available at <http://www.gnu.org/licenses/>.
*/

import QtQuick 2.10
import QtQuick.Controls 2.3

Control {
  id: control
  objectName: "MLDoubleSpinBox"

  // Standard SpinBox API properties (v2.4)
  property double value: 0.0
  property double from: 0.0
  property double to: 100.0
  property double stepSize: 1.0
  property bool editable: true
  property bool wrap: true
  property QtObject validator: doubleValidator    
  property int inputMethodHints: Qt.ImhFormattedNumbersOnly
  readonly property string displayText: textFromValue(value, effectiveLocale)
  readonly property bool inputMethodComposing: textInputItem ? textInputItem.inputMethodComposing : false

  // Custom properties
  property int decimals: 2                  
  property int notation: DoubleValidator.StandardNotation   
  property string inputMask                 
  property bool selectByMouse: true         
  property bool useLocaleFormat: true       
  property bool showGroupSeparator: true    
  property bool trimExtraZeros: true        
  property string prefix                    
  property string suffix                    
  property int pageSteps: 10                
  property int buttonRepeatDelay: 300       
  property int buttonRepeatInterval: 100    

  readonly property string cleanText: getCleanText(displayText)                            
  readonly property bool acceptableInput: textInputItem && textInputItem.acceptableInput   
  readonly property real topValue: Math.max(from, to)                                      
  readonly property real botValue: Math.min(from, to)                                      

  readonly property SpinBox spinBoxItem: contentItem
  property Item textInputItem: spinBoxItem ? spinBoxItem.contentItem : null

  readonly property QtObject doubleValidator: DoubleValidator {
    top: control.topValue
    bottom: control.botValue
    decimals: Math.max(control.decimals, 0)
    notation: control.notation
    locale: control.effectiveLocale.name
  }

  readonly property QtObject regExpValidator: RegExpValidator { regExp: control.doubleValidationRegEx(); }

  // signals

  signal valueModified()   

  // QtQuick Control properties

  // By default wheel is enabled only if editor has active focus or item is not editable.
  wheelEnabled: !editable || (textInputItem && textInputItem.activeFocus)

  // The spin box itself... it's really only here for its buttons and overall formatting, we ignore its actual value/etc.
  contentItem: SpinBox {
    width: control.availableWidth
    height: control.availableHeight
    editable: control.editable
    inputMethodHints: control.inputMethodHints
    validator: control.validator
    from: -0x7FFFFFFF; to: 0x7FFFFFFF;  // prevent interference with our real from/to values
    // wrap peroperty is set below as a Binding in case SpinBox vesion is < 2.3 (Qt 5.10).
  }

  // Public function API

  function increase() {
    stepBy(1);
  }

  function decrease() {
    stepBy(-1);
  }

  function stepBy(steps, noWrap) {
    // always use current editor value in case user has changed it w/out losing focus
    setValue(textValue() + (stepSize * steps), noWrap);
  }

  function setValue(newValue, noWrap, notModified)
  {
    if (!wrap || noWrap)
      newValue = Math.max(Math.min(newValue, control.topValue), control.botValue);
    else if (newValue < control.botValue)
      newValue = control.topValue;
    else if (newValue > control.topValue)
      newValue = control.botValue;

    newValue = Number(newValue.toFixed(Math.max(decimals, 0)));  // round

    if (value !== newValue) {
      isValidated = true;
      value = newValue;
      isValidated = false;
      if (!notModified)
        valueModified();
      if (spinBoxItem)
        spinBoxItem.value = 0;  // reset this to prevent it from disabling the buttons or other weirdness
      //console.log("setValue:", newValue.toFixed(control.decimals));
      return true;
    }
    return false;
  }

  function textFromValue(value, locale)
  {
    if (!locale)
      locale = effectiveLocale;

    var text = value.toLocaleString(locale, (notation === DoubleValidator.StandardNotation ? 'f' : 'e'), Math.max(decimals, 0));

    if (!showGroupSeparator && locale.name !== "C")
      text = text.replace(new RegExp("\\" + locale.groupSeparator, "g"), "");
    if (trimExtraZeros) {
      var pt = locale.decimalPoint;
      var ex = new RegExp("\\" + pt + "0*$|(\\" + pt + "\\d*[1-9])(0+)$").exec(text);
      if (ex)
        text = text.replace(ex[0], ex[1] || "");
    }

    if (prefix)
      text = prefix + text;
    if (suffix)
      text = text + suffix;

    return text;
  }

  function valueFromText(text, locale)
  {
    if (!locale)
      locale = effectiveLocale;
    // strip prefix/suffix, or custom pre-processor
    text = getCleanText(text, locale);
    // We need to clean the string before using Number::fromLocaleString because it throws errors when the input format isn't valid, eg. thousands separator in the wrong place. D'oh.
    var re = "[^\\+\\-\\d\\" + locale.decimalPoint + locale.exponential + "]+";
    text = text.replace(new RegExp(re, "gi"), "");
    if (!text.length)
      text = "0";
    //console.log("valueFromText:", text, locale.name, Number.fromLocaleString(locale, text));
    return Number.fromLocaleString(locale, text);
  }

  function getCleanText(text, locale)
  {
    text = String(text);
    if (prefix)
      text = text.replace(prefixRegEx, "");
    if (suffix)
      text = text.replace(suffixRegEx, "");
    return text.trim();
  }

  function escapeRegExpChars(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  function escapeInputMaskChars(string) {
    return string.replace(/[{}\[\]\\><!#09anxdhb]/gi, '\\$&');
  }

  function doubleValidationRegEx()
  {
    var locale = effectiveLocale,
        pnt = locale.decimalPoint,
        grp = locale.groupSeparator,
        exp = locale.exponential,
        pfx = escapeRegExpChars(prefix),
        sfx = escapeRegExpChars(suffix),
        expRe = "(?:" + exp + "[+-]?[\\d]+)?",
        re = "^" + pfx + "[+-]?(?:[\\d]{1,3}\\" + grp + "?)+\\" + pnt + "?[\\d]*" + expRe + sfx + "$";
    // ^[+-]?(?:[\d]{1,3},?)+\.?[\d]*(?:e[+-]?[\d]+)?$
    return new RegExp(re, "i");
  }

  // internals

  property bool isValidated: false  
  property bool completed: false    
  readonly property var defaultLocale: Qt.locale("C")  
  readonly property var effectiveLocale: useLocaleFormat ? locale : defaultLocale  
  readonly property var prefixRegEx: new RegExp("^" + escapeRegExpChars(prefix))  
  readonly property var suffixRegEx: new RegExp(escapeRegExpChars(suffix) + "$")  


  
  function textValue() {
    return textInputItem ? valueFromText(textInputItem.text, effectiveLocale) : 0;
  }

  function updateValueFromText() {
    if (!setValue(textValue(), true))
      updateUi();  // make sure the text is formatted anyway
  }

  function handleKeyEvent(event)
  {
    var steps = 0;
    if (event.key === Qt.Key_Up)
      steps = 1;
    else if (event.key === Qt.Key_Down)
      steps = -1;
    else if (event.key === Qt.Key_PageUp)
      steps = control.pageSteps;
    else if (event.key === Qt.Key_PageDown)
      steps = -control.pageSteps;
    else if (event.key !== Qt.Key_Enter && event.key !== Qt.Key_Return)
      return;

    event.accepted = true;

    if (steps)
      stepBy(steps);
    else
      updateValueFromText();
  }

  function toggleButtonPress(press, increment)
  {
    if (!press) {
      btnRepeatTimer.stop();
      return;
    }

    if (increment)
      increase();
    else
      decrease();
    btnRepeatTimer.increment = increment;
    btnRepeatTimer.start();
  }

  function updateUi()
  {
    if (!completed)
      return;

    if (textInputItem)
      textInputItem.text = textFromValue(value, effectiveLocale);

    if (spinBoxItem) {
      if (spinBoxItem.up && spinBoxItem.up.indicator)
        spinBoxItem.up.indicator.enabled = (wrap || value < topValue);
      if (spinBoxItem.down && spinBoxItem.down.indicator)
        spinBoxItem.down.indicator.enabled = (wrap || value > botValue);
    }
  }

  onValueChanged: {
    if (!completed)
      return;
    if (!isValidated)
      setValue(value, true, true);
    updateUi();
  }

  // We need to override spin box arrow key events to distinguish from +/- button presses, otherwise we get double repeats.
  onSpinBoxItemChanged: {
    if (spinBoxItem)
      spinBoxItem.Keys.forwardTo = [control];
  }

  Component.onCompleted: {
    completed = true;
    // An initial value may have been set, but not validated. Do that now.
    if (!setValue(value, true, true))
      updateUi();  // in case it hasn't changed
  }

  onWrapChanged: updateUi()
  onNotationChanged: updateUi()
  onTrimExtraZerosChanged: updateUi()
  onShowGroupSeparatorChanged: updateUi()
  onEffectiveLocaleChanged: updateUi()
  Keys.onPressed: handleKeyEvent(event)

  Connections {
    target: control.spinBoxItem ? control.spinBoxItem.up : null
    onPressedChanged: control.toggleButtonPress(control.spinBoxItem.up.pressed, true)
  }

  Connections {
    target: control.spinBoxItem ? control.spinBoxItem.down : null
    onPressedChanged: control.toggleButtonPress(control.spinBoxItem.down.pressed, false)
  }

  Connections {
    target: control.textInputItem
    // Checking active focus works better than onEditingFinished because the latter doesn't fire if input is invalid (nor does it fix it up automatically).
    onActiveFocusChanged: {
      if (!control.textInputItem.activeFocus)
        control.updateValueFromText();
    }
  }

  // We use a binding here just in case the resident SpinBox is older than v2.3
  Binding {
    target: control.spinBoxItem
    when: control.spinBoxItem && typeof control.spinBoxItem.wrap !== "undefined"
    property: "wrap"
    value: control.wrap
  }

  Binding {
    target: control.textInputItem
    property: "selectByMouse"
    value: control.selectByMouse
  }

  Binding {
    target: control.textInputItem
    property: "inputMask"
    value: control.inputMask
  }

  // Timer for firing the +/- button repeat events while they're held down.
  Timer {
    id: btnRepeatTimer
    property bool delay: true
    property bool increment: true
    interval: delay ? control.buttonRepeatDelay : control.buttonRepeatInterval
    repeat: true
    onRunningChanged: delay = true
    onTriggered: {
      if (delay)
        delay = false;
      else if (increment)
        control.increase();
      else
        control.decrease();
    }
  }

  // Wheel/scroll action detection area
  MouseArea {
    anchors.fill: control
    z: control.contentItem.z + 1
    acceptedButtons: Qt.NoButton
    enabled: control.wheelEnabled
    onWheel: {
      var delta = (wheel.angleDelta.y === 0.0 ? -wheel.angleDelta.x : wheel.angleDelta.y) / 120;
      if (wheel.inverted)
        delta *= -1;
      if (wheel.modifiers & Qt.ControlModifier)
        delta *= control.pageSteps;
      control.stepBy(delta);
    }
  }

}