qtpropertymanager.cpp

    In addition, QtDoublePropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes, and the rangeChanged() signal which is emitted whenever
    such a property changes its range of valid values.

    \sa QtAbstractPropertyManager, QtDoubleSpinBoxFactory
*/

/**
    \fn void QtDoublePropertyManager::valueChanged(QtProperty *property, double
   value)

    This signal is emitted whenever a property created by this manager
    changes its value, passing a pointer to the \a property and the new
    \a value as parameters.

    \sa setValue()
*/

/**
    \fn void QtDoublePropertyManager::rangeChanged(QtProperty *property, double
   minimum, double maximum)

    This signal is emitted whenever a property created by this manager
    changes its range of valid values, passing a pointer to the
    \a property and the new \a minimum and \a maximum values

    \sa setRange()
*/

/**
    \fn void QtDoublePropertyManager::decimalsChanged(QtProperty *property, int
   prec)

    This signal is emitted whenever a property created by this manager
    changes its precision of value, passing a pointer to the
    \a property and the new \a prec value

    \sa setDecimals()
*/

/**
    \fn void QtDoublePropertyManager::singleStepChanged(QtProperty *property,
   double step)

    This signal is emitted whenever a property created by this manager
    changes its single step property, passing a pointer to the
    \a property and the new \a step value

    \sa setSingleStep()
*/

/**
    Creates a manager with the given \a parent.
*/
QtDoublePropertyManager::QtDoublePropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtDoublePropertyManagerPrivate;
  d_ptr->q_ptr = this;
}

/**
    Destroys  this manager, and all the properties it has created.
*/
QtDoublePropertyManager::~QtDoublePropertyManager() {
  clear();
  delete d_ptr;
}

/**
    Returns the given \a property's value.

    If the given property is not managed by this manager, this
    function returns 0.

    \sa setValue()
*/
double QtDoublePropertyManager::value(const QtProperty *property) const {
  return getValue<double>(d_ptr->m_values, property, 0.0);
}

/**
    Returns the given \a property's minimum value.

    \sa maximum(), setRange()
*/
double QtDoublePropertyManager::minimum(const QtProperty *property) const {
  return getMinimum<double>(d_ptr->m_values, property, 0.0);
}

/**
    Returns the given \a property's maximum value.

    \sa minimum(), setRange()
*/
double QtDoublePropertyManager::maximum(const QtProperty *property) const {
  return getMaximum<double>(d_ptr->m_values, property, 0.0);
}

/**
    Returns the given \a property's step value.

    The step is typically used to increment or decrement a property value while
   pressing an arrow key.

    \sa setSingleStep()
*/
double QtDoublePropertyManager::singleStep(const QtProperty *property) const {
  return getData<double>(d_ptr->m_values,
                         &QtDoublePropertyManagerPrivate::Data::singleStep,
                         property, 0);
}

/**
    Returns the given \a property's precision, in decimals.

    \sa setDecimals()
*/
int QtDoublePropertyManager::decimals(const QtProperty *property) const {
  return getData<int>(d_ptr->m_values,
                      &QtDoublePropertyManagerPrivate::Data::decimals, property,
                      0);
}

/**
    \reimp
*/
QString QtDoublePropertyManager::valueText(const QtProperty *property) const {
  const QtDoublePropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();
  double absVal = fabs(it.value().val);
  char format = absVal > 1e5 || (absVal != 0 && absVal < 1e-5) ? 'e' : 'f';
  return QString::number(it.value().val, format, it.value().decimals);
}

/**
    \fn void QtDoublePropertyManager::setValue(QtProperty *property, double
   value)

    Sets the value of the given \a property to \a value.

    If the specified \a value is not valid according to the given
    \a property's range, the \a value is adjusted to the nearest valid value
    within the range.

    \sa value(), setRange(), valueChanged()
*/
void QtDoublePropertyManager::setValue(QtProperty *property, double val) {
  void (QtDoublePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *,
                                                              double) = 0;
  setValueInRange<double, QtDoublePropertyManagerPrivate,
                  QtDoublePropertyManager, double>(
      this, d_ptr, &QtDoublePropertyManager::propertyChanged,
      &QtDoublePropertyManager::valueChanged, property, val,
      setSubPropertyValue);
}

/**
    Sets the step value for the given \a property to \a step.

    The step is typically used to increment or decrement a property value while
   pressing an arrow key.

    \sa singleStep()
*/
void QtDoublePropertyManager::setSingleStep(QtProperty *property, double step) {
  const QtDoublePropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

  QtDoublePropertyManagerPrivate::Data data = it.value();

  if (step < 0)
    step = 0;

  if (data.singleStep == step)
    return;

  data.singleStep = step;

  it.value() = data;

  emit singleStepChanged(property, data.singleStep);
}

/**
    \fn void QtDoublePropertyManager::setDecimals(QtProperty *property, int
   prec)

    Sets the precision of the given \a property to \a prec.

    The valid decimal range is 0-13. The default is 2.

    \sa decimals()
*/
void QtDoublePropertyManager::setDecimals(QtProperty *property, int prec) {
  const QtDoublePropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

  QtDoublePropertyManagerPrivate::Data data = it.value();

  if (prec > 13)
    prec = 13;
  else if (prec < 0)
    prec = 0;

  if (data.decimals == prec)
    return;

  data.decimals = prec;

  it.value() = data;

  emit decimalsChanged(property, data.decimals);
}

/**
    Sets the minimum value for the given \a property to \a minVal.

    When setting the minimum value, the maximum and current values are
    adjusted if necessary (ensuring that the range remains valid and
    that the current value is within in the range).

    \sa minimum(), setRange(), rangeChanged()
*/
void QtDoublePropertyManager::setMinimum(QtProperty *property, double minVal) {
  setMinimumValue<double, QtDoublePropertyManagerPrivate,
                  QtDoublePropertyManager, double,
                  QtDoublePropertyManagerPrivate::Data>(
      this, d_ptr, &QtDoublePropertyManager::propertyChanged,
      &QtDoublePropertyManager::valueChanged,
      &QtDoublePropertyManager::rangeChanged, property, minVal);
}

/**
    Sets the maximum value for the given \a property to \a maxVal.

    When setting the maximum value, the minimum and current values are
    adjusted if necessary (ensuring that the range remains valid and
    that the current value is within in the range).

    \sa maximum(), setRange(), rangeChanged()
*/
void QtDoublePropertyManager::setMaximum(QtProperty *property, double maxVal) {
  setMaximumValue<double, QtDoublePropertyManagerPrivate,
                  QtDoublePropertyManager, double,
                  QtDoublePropertyManagerPrivate::Data>(
      this, d_ptr, &QtDoublePropertyManager::propertyChanged,
      &QtDoublePropertyManager::valueChanged,
      &QtDoublePropertyManager::rangeChanged, property, maxVal);
}

/**
    \fn void QtDoublePropertyManager::setRange(QtProperty *property, double
   minimum, double maximum)

    Sets the range of valid values.

    This is a convenience function defining the range of valid values
    in one go; setting the \a minimum and \a maximum values for the
    given \a property with a single function call.

    When setting a new range, the current value is adjusted if
    necessary (ensuring that the value remains within range).

    \sa setMinimum(), setMaximum(), rangeChanged()
*/
void QtDoublePropertyManager::setRange(QtProperty *property, double minVal,
                                       double maxVal) {
  void (QtDoublePropertyManagerPrivate::*setSubPropertyRange)(
      QtProperty *, double, double, double) = 0;
  setBorderValues<double, QtDoublePropertyManagerPrivate,
                  QtDoublePropertyManager, double>(
      this, d_ptr, &QtDoublePropertyManager::propertyChanged,
      &QtDoublePropertyManager::valueChanged,
      &QtDoublePropertyManager::rangeChanged, property, minVal, maxVal,
      setSubPropertyRange);
}

/**
    \reimp
*/
void QtDoublePropertyManager::initializeProperty(QtProperty *property) {
  d_ptr->m_values[property] = QtDoublePropertyManagerPrivate::Data();
}

/**
    \reimp
*/
void QtDoublePropertyManager::uninitializeProperty(QtProperty *property) {
  d_ptr->m_values.remove(property);
}

// QtStringPropertyManager

class QtStringPropertyManagerPrivate {
  QtStringPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtStringPropertyManager)
public:
  struct Data {
    Data()
        : regExp(QString(QLatin1Char('*')), Qt::CaseSensitive,
                 QRegExp::Wildcard) {}
    QString val;
    QRegExp regExp;
  };

  typedef QMap<const QtProperty *, Data> PropertyValueMap;
  QMap<const QtProperty *, Data> m_values;
};

/**
    \class QtStringPropertyManager

    \brief The QtStringPropertyManager provides and manages QString properties.

    A string property's value can be retrieved using the value()
    function, and set using the setValue() slot.

    The current value can be checked against a regular expression. To
    set the regular expression use the setRegExp() slot, use the
    regExp() function to retrieve the currently set expression.

    In addition, QtStringPropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes, and the regExpChanged() signal which is emitted whenever
    such a property changes its currently set regular expression.

    \sa QtAbstractPropertyManager, QtLineEditFactory
*/

/**
    \fn void QtStringPropertyManager::valueChanged(QtProperty *property, const
   QString &value)

    This signal is emitted whenever a property created by this manager
    changes its value, passing a pointer to the \a property and the
    new \a value as parameters.

    \sa setValue()
*/

/**
    \fn void QtStringPropertyManager::regExpChanged(QtProperty *property, const
   QRegExp &regExp)

    This signal is emitted whenever a property created by this manager
    changes its currenlty set regular expression, passing a pointer to
    the \a property and the new \a regExp as parameters.

    \sa setRegExp()
*/

/**
    Creates a manager with the given \a parent.
*/
QtStringPropertyManager::QtStringPropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtStringPropertyManagerPrivate;
  d_ptr->q_ptr = this;
}

/**
    Destroys this manager, and all the properties it has created.
*/
QtStringPropertyManager::~QtStringPropertyManager() {
  clear();
  delete d_ptr;
}

/**
    Returns the given \a property's value.

    If the given property is not managed by this manager, this
    function returns an empty string.

    \sa setValue()
*/
QString QtStringPropertyManager::value(const QtProperty *property) const {
  return getValue<QString>(d_ptr->m_values, property);
}

/**
    Returns the given \a property's currently set regular expression.

    If the given \a property is not managed by this manager, this
    function returns an empty expression.

    \sa setRegExp()
*/
QRegExp QtStringPropertyManager::regExp(const QtProperty *property) const {
  return getData<QRegExp>(d_ptr->m_values,
                          &QtStringPropertyManagerPrivate::Data::regExp,
                          property, QRegExp());
}

/**
    \reimp
*/
QString QtStringPropertyManager::valueText(const QtProperty *property) const {
  const QtStringPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();
  return it.value().val;
}

/**
    \fn void QtStringPropertyManager::setValue(QtProperty *property, const
   QString &value)

    Sets the value of the given \a property to \a value.

    If the specified \a value doesn't match the given \a property's
    regular expression, this function does nothing.

    \sa value(), setRegExp(), valueChanged()
*/
void QtStringPropertyManager::setValue(QtProperty *property,
                                       const QString &val) {
  const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

  QtStringPropertyManagerPrivate::Data data = it.value();

  if (data.val == val)
    return;

  if (data.regExp.isValid() && !data.regExp.exactMatch(val))
    return;

  data.val = val;

  it.value() = data;

  emit propertyChanged(property);
  emit valueChanged(property, data.val);
}

/**
    Sets the regular expression of the given \a property to \a regExp.

    \sa regExp(), setValue(), regExpChanged()
*/
void QtStringPropertyManager::setRegExp(QtProperty *property,
                                        const QRegExp &regExp) {
  const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

  QtStringPropertyManagerPrivate::Data data = it.value();

  if (data.regExp == regExp)
    return;

  data.regExp = regExp;

  it.value() = data;

  emit regExpChanged(property, data.regExp);
}

/**
    \reimp
*/
void QtStringPropertyManager::initializeProperty(QtProperty *property) {
  d_ptr->m_values[property] = QtStringPropertyManagerPrivate::Data();
}

/**
    \reimp
*/
void QtStringPropertyManager::uninitializeProperty(QtProperty *property) {
  d_ptr->m_values.remove(property);
}

// QtBoolPropertyManager

class QtBoolPropertyManagerPrivate {
  QtBoolPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtBoolPropertyManager)
public:
  QMap<const QtProperty *, bool> m_values;
};

/**
    \class QtBoolPropertyManager

    \brief The QtBoolPropertyManager class provides and manages boolean
   properties.

    The property's value can be retrieved using the value() function,
    and set using the setValue() slot.

    In addition, QtBoolPropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes.

    \sa QtAbstractPropertyManager, QtCheckBoxFactory
*/

/**
    \fn void QtBoolPropertyManager::valueChanged(QtProperty *property, bool
   value)

    This signal is emitted whenever a property created by this manager
    changes its value, passing a pointer to the \a property and the
    new \a value as parameters.
*/

/**
    Creates a manager with the given \a parent.
*/
QtBoolPropertyManager::QtBoolPropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtBoolPropertyManagerPrivate;
  d_ptr->q_ptr = this;
}

/**
    Destroys this manager, and all the properties it has created.
*/
QtBoolPropertyManager::~QtBoolPropertyManager() {
  clear();
  delete d_ptr;
}

/**
    Returns the given \a property's value.

    If the given \a property is not managed by \e this manager, this
    function returns false.

    \sa setValue()
*/
bool QtBoolPropertyManager::value(const QtProperty *property) const {
  return d_ptr->m_values.value(property, false);
}

/**
    \reimp
*/
QString QtBoolPropertyManager::valueText(const QtProperty *property) const {
  const QMap<const QtProperty *, bool>::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();

  static const QString trueText = tr("True");
  static const QString falseText = tr("False");
  return it.value() ? trueText : falseText;
}

// Return an icon containing a check box indicator
static QIcon drawCheckBox(bool value) {
  QStyleOptionButton opt;
  opt.state |= value ? QStyle::State_On : QStyle::State_Off;
  opt.state |= QStyle::State_Enabled;
  const QStyle *style = QApplication::style();
  // Figure out size of an indicator and make sure it is not scaled down in a
  // list view item
  // by making the pixmap as big as a list view icon and centering the indicator
  // in it.
  // (if it is smaller, it can't be helped)
  const int indicatorWidth =
      style->pixelMetric(QStyle::PM_IndicatorWidth, &opt);
  const int indicatorHeight =
      style->pixelMetric(QStyle::PM_IndicatorHeight, &opt);
  const int listViewIconSize = indicatorWidth;
  const int pixmapWidth = indicatorWidth;
  const int pixmapHeight = qMax(indicatorHeight, listViewIconSize);

  opt.rect = QRect(0, 0, indicatorWidth, indicatorHeight);
  QPixmap pixmap = QPixmap(pixmapWidth, pixmapHeight);
  pixmap.fill(Qt::transparent);
  {
    // Center?
    const int xoff =
        (pixmapWidth > indicatorWidth) ? (pixmapWidth - indicatorWidth) / 2 : 0;
    const int yoff = (pixmapHeight > indicatorHeight)
                         ? (pixmapHeight - indicatorHeight) / 2
                         : 0;
    QPainter painter(&pixmap);
    painter.translate(xoff, yoff);
    style->drawPrimitive(QStyle::PE_IndicatorCheckBox, &opt, &painter);
  }
  return QIcon(pixmap);
}

/**
    \reimp
*/
QIcon QtBoolPropertyManager::valueIcon(const QtProperty *property) const {
  const QMap<const QtProperty *, bool>::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QIcon();

  static const QIcon checkedIcon = drawCheckBox(true);
  static const QIcon uncheckedIcon = drawCheckBox(false);
  return it.value() ? checkedIcon : uncheckedIcon;
}

/**
    \fn void QtBoolPropertyManager::setValue(QtProperty *property, bool value)

    Sets the value of the given \a property to \a value.

    \sa value()
*/
void QtBoolPropertyManager::setValue(QtProperty *property, bool val) {
  setSimpleValue<bool, bool, QtBoolPropertyManager>(
      d_ptr->m_values, this, &QtBoolPropertyManager::propertyChanged,
      &QtBoolPropertyManager::valueChanged, property, val);
}

/**
    \reimp
*/
void QtBoolPropertyManager::initializeProperty(QtProperty *property) {
  d_ptr->m_values[property] = false;
}

/**
    \reimp
*/
void QtBoolPropertyManager::uninitializeProperty(QtProperty *property) {
  d_ptr->m_values.remove(property);
}

// QtDatePropertyManager

class QtDatePropertyManagerPrivate {
  QtDatePropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtDatePropertyManager)
public:
  struct Data {
    Data()
        : val(QDate::currentDate()), minVal(QDate(1752, 9, 14)),
          maxVal(QDate(7999, 12, 31)) {}
    QDate val;
    QDate minVal;
    QDate maxVal;
    QDate minimumValue() const { return minVal; }
    QDate maximumValue() const { return maxVal; }
    void setMinimumValue(const QDate &newMinVal) {
      setSimpleMinimumData(this, newMinVal);
    }
    void setMaximumValue(const QDate &newMaxVal) {
      setSimpleMaximumData(this, newMaxVal);
    }
  };

  QString m_format;

  typedef QMap<const QtProperty *, Data> PropertyValueMap;
  QMap<const QtProperty *, Data> m_values;
};

/**
    \class QtDatePropertyManager

    \brief The QtDatePropertyManager provides and manages QDate properties.

    A date property has a current value, and a range specifying the
    valid dates. The range is defined by a minimum and a maximum
    value.

    The property's values can be retrieved using the minimum(),
    maximum() and value() functions, and can be set using the
    setMinimum(), setMaximum() and setValue() slots. Alternatively,
    the range can be defined in one go using the setRange() slot.

    In addition, QtDatePropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes, and the rangeChanged() signal which is emitted whenever
    such a property changes its range of valid dates.

    \sa QtAbstractPropertyManager, QtDateEditFactory, QtDateTimePropertyManager
*/

/**
    \fn void QtDatePropertyManager::valueChanged(QtProperty *property, const
   QDate &value)

    This signal is emitted whenever a property created by this manager
    changes its value, passing a pointer to the \a property and the new
    \a value as parameters.

    \sa setValue()
*/

/**
    \fn void QtDatePropertyManager::rangeChanged(QtProperty *property, const
   QDate &minimum, const QDate &maximum)

    This signal is emitted whenever a property created by this manager
    changes its range of valid dates, passing a pointer to the \a
    property and the new \a minimum and \a maximum dates.

    \sa setRange()
*/

/**
    Creates a manager with the given \a parent.
*/
QtDatePropertyManager::QtDatePropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtDatePropertyManagerPrivate;
  d_ptr->q_ptr = this;

  QLocale loc;
  d_ptr->m_format = loc.dateFormat(QLocale::ShortFormat);
}

/**
    Destroys this manager, and all the properties it has created.
*/
QtDatePropertyManager::~QtDatePropertyManager() {
  clear();
  delete d_ptr;
}

/**
    Returns the given \a property's value.

    If the given \a property is not managed by \e this manager, this
    function returns an invalid date.

    \sa setValue()
*/
QDate QtDatePropertyManager::value(const QtProperty *property) const {
  return getValue<QDate>(d_ptr->m_values, property);
}

/**
    Returns the given \a  property's  minimum date.

    \sa maximum(), setRange()
*/
QDate QtDatePropertyManager::minimum(const QtProperty *property) const {
  return getMinimum<QDate>(d_ptr->m_values, property);
}

/**
    Returns the given \a property's maximum date.

    \sa minimum(), setRange()
*/
QDate QtDatePropertyManager::maximum(const QtProperty *property) const {
  return getMaximum<QDate>(d_ptr->m_values, property);
}

/**
    \reimp
*/
QString QtDatePropertyManager::valueText(const QtProperty *property) const {
  const QtDatePropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();
  return it.value().val.toString(d_ptr->m_format);
}

/**
    \fn void QtDatePropertyManager::setValue(QtProperty *property, const QDate
   &value)

    Sets the value of the given \a property to \a value.

    If the specified \a value is not a valid date according to the
    given \a property's range, the value is adjusted to the nearest
    valid value within the range.

    \sa value(), setRange(), valueChanged()
*/
void QtDatePropertyManager::setValue(QtProperty *property, const QDate &val) {
  void (QtDatePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *,
                                                            const QDate &) = 0;
  setValueInRange<const QDate &, QtDatePropertyManagerPrivate,
                  QtDatePropertyManager, const QDate>(
      this, d_ptr, &QtDatePropertyManager::propertyChanged,
      &QtDatePropertyManager::valueChanged, property, val, setSubPropertyValue);
}

/**
    Sets the minimum value for the given \a property to \a minVal.

    When setting the minimum value, the maximum and current values are
    adjusted if necessary (ensuring that the range remains valid and
    that the current value is within in the range).

    \sa minimum(), setRange()
*/
void QtDatePropertyManager::setMinimum(QtProperty *property,
                                       const QDate &minVal) {
  setMinimumValue<const QDate &, QtDatePropertyManagerPrivate,
                  QtDatePropertyManager, QDate,
                  QtDatePropertyManagerPrivate::Data>(
      this, d_ptr, &QtDatePropertyManager::propertyChanged,
      &QtDatePropertyManager::valueChanged,
      &QtDatePropertyManager::rangeChanged, property, minVal);
}

/**
    Sets the maximum value for the given \a property to \a maxVal.

    When setting the maximum value, the minimum and current
    values are adjusted if necessary (ensuring that the range remains
    valid and that the current value is within in the range).

    \sa maximum(), setRange()
*/
void QtDatePropertyManager::setMaximum(QtProperty *property,
                                       const QDate &maxVal) {
  setMaximumValue<const QDate &, QtDatePropertyManagerPrivate,
                  QtDatePropertyManager, QDate,
                  QtDatePropertyManagerPrivate::Data>(
      this, d_ptr, &QtDatePropertyManager::propertyChanged,
      &QtDatePropertyManager::valueChanged,
      &QtDatePropertyManager::rangeChanged, property, maxVal);
}

/**
    \fn void QtDatePropertyManager::setRange(QtProperty *property, const QDate
   &minimum, const QDate &maximum)

    Sets the range of valid dates.

    This is a convenience function defining the range of valid dates
    in one go; setting the \a minimum and \a maximum values for the
    given \a property with a single function call.

    When setting a new date range, the current value is adjusted if
    necessary (ensuring that the value remains in date range).

    \sa setMinimum(), setMaximum(), rangeChanged()
*/
void QtDatePropertyManager::setRange(QtProperty *property, const QDate &minVal,
                                     const QDate &maxVal) {
  void (QtDatePropertyManagerPrivate::*setSubPropertyRange)(
      QtProperty *, const QDate &, const QDate &, const QDate &) = 0;
  setBorderValues<const QDate &, QtDatePropertyManagerPrivate,
                  QtDatePropertyManager, QDate>(
      this, d_ptr, &QtDatePropertyManager::propertyChanged,
      &QtDatePropertyManager::valueChanged,
      &QtDatePropertyManager::rangeChanged, property, minVal, maxVal,
      setSubPropertyRange);
}

/**
    \reimp
*/
void QtDatePropertyManager::initializeProperty(QtProperty *property) {
  d_ptr->m_values[property] = QtDatePropertyManagerPrivate::Data();
}

/**
    \reimp
*/
void QtDatePropertyManager::uninitializeProperty(QtProperty *property) {
  d_ptr->m_values.remove(property);
}

// QtTimePropertyManager

class QtTimePropertyManagerPrivate {
  QtTimePropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtTimePropertyManager)
public:
  QString m_format;

  typedef QMap<const QtProperty *, QTime> PropertyValueMap;
  PropertyValueMap m_values;
};

/**
    \class QtTimePropertyManager

    \brief The QtTimePropertyManager provides and manages QTime properties.

    A time property's value can be retrieved using the value()
    function, and set using the setValue() slot.

    In addition, QtTimePropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes.

    \sa QtAbstractPropertyManager, QtTimeEditFactory
*/

/**
    \fn void QtTimePropertyManager::valueChanged(QtProperty *property, const
   QTime &value)

    This signal is emitted whenever a property created by this manager
    changes its value, passing a pointer to the \a property and the
    new \a value as parameters.

    \sa setValue()
*/

/**
    Creates a manager with the given \a parent.
*/
QtTimePropertyManager::QtTimePropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtTimePropertyManagerPrivate;
  d_ptr->q_ptr = this;

  QLocale loc;
  d_ptr->m_format = loc.timeFormat(QLocale::ShortFormat);
}

/**
    Destroys this manager, and all the properties it has created.
*/
QtTimePropertyManager::~QtTimePropertyManager() {
  clear();
  delete d_ptr;
}

/**
    Returns the given \a property's value.

    If the given property is not managed by this manager, this
    function returns an invalid time object.

    \sa setValue()
*/
QTime QtTimePropertyManager::value(const QtProperty *property) const {
  return d_ptr->m_values.value(property, QTime());
}

/**
    \reimp
*/
QString QtTimePropertyManager::valueText(const QtProperty *property) const {
  const QtTimePropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();
  return it.value().toString(d_ptr->m_format);
}

/**
    \fn void QtTimePropertyManager::setValue(QtProperty *property, const QTime
   &value)

    Sets the value of the given \a property to \a value.

    \sa value(), valueChanged()
*/
void QtTimePropertyManager::setValue(QtProperty *property, const QTime &val) {
  setSimpleValue<const QTime &, QTime, QtTimePropertyManager>(
      d_ptr->m_values, this, &QtTimePropertyManager::propertyChanged,
      &QtTimePropertyManager::valueChanged, property, val);
}

/**
    \reimp
*/
void QtTimePropertyManager::initializeProperty(QtProperty *property) {
  d_ptr->m_values[property] = QTime::currentTime();
}

/**
    \reimp
*/
void QtTimePropertyManager::uninitializeProperty(QtProperty *property) {
  d_ptr->m_values.remove(property);
}

// QtDateTimePropertyManager

class QtDateTimePropertyManagerPrivate {
  QtDateTimePropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtDateTimePropertyManager)
public:
  QString m_format;

  typedef QMap<const QtProperty *, QDateTime> PropertyValueMap;
  PropertyValueMap m_values;
};

/** \class QtDateTimePropertyManager

    \brief The QtDateTimePropertyManager provides and manages QDateTime
   properties.

    A date and time property has a current value which can be
    retrieved using the value() function, and set using the setValue()