qtpropertymanager.cpp

};

void QtFlagPropertyManagerPrivate::slotBoolChanged(QtProperty *property,
                                                   bool value) {
  QtProperty *prop = m_flagToProperty.value(property, 0);
  if (prop == 0)
    return;

  QListIterator<QtProperty *> itProp(m_propertyToFlags[prop]);
  int level = 0;
  while (itProp.hasNext()) {
    QtProperty *p = itProp.next();
    if (p == property) {
      int v = m_values[prop].val;
      if (value) {
        v |= (1 << level);
      } else {
        v &= ~(1 << level);
      }
      q_ptr->setValue(prop, v);
      return;
    }
    level++;
  }
}

void QtFlagPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property) {
  QtProperty *flagProperty = m_flagToProperty.value(property, 0);
  if (flagProperty == 0)
    return;

  m_propertyToFlags[flagProperty].replace(
      m_propertyToFlags[flagProperty].indexOf(property), 0);
  m_flagToProperty.remove(property);
}

/**
    \class QtFlagPropertyManager

    \brief The QtFlagPropertyManager provides and manages flag properties.

    Each flag property has an associated list of flag names which can
    be retrieved using the flagNames() function, and set using the
    corresponding setFlagNames() function.

    The flag manager provides properties with nested boolean
    subproperties representing each flag, i.e. a flag property's value
    is the binary combination of the subproperties' values. A
    property's value can be retrieved and set using the value() and
    setValue() slots respectively. The combination of flags is represented
    by single int value - that's why it's possible to store up to
    32 independent flags in one flag property.

    The subproperties are created by a QtBoolPropertyManager object. This
    manager can be retrieved using the subBoolPropertyManager() function. In
    order to provide editing widgets for the subproperties in a
    property browser widget, this manager must be associated with an
    editor factory.

    In addition, QtFlagPropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes, and the flagNamesChanged() signal which is emitted
    whenever the list of flag names is altered.

    \sa QtAbstractPropertyManager, QtBoolPropertyManager
*/

/**
    \fn void QtFlagPropertyManager::valueChanged(QtProperty *property, int
   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 QtFlagPropertyManager::flagNamesChanged(QtProperty *property, const
   QStringList &names)

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

    \sa setFlagNames()
*/

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

  d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
  connect(d_ptr->m_boolPropertyManager,
          SIGNAL(valueChanged(QtProperty *, bool)), this,
          SLOT(slotBoolChanged(QtProperty *, bool)));
  connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
}

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

/**
    Returns the manager that produces the nested boolean subproperties
    representing each flag.

    In order to provide editing widgets for the subproperties in a
    property browser widget, this manager must be associated with an
    editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtBoolPropertyManager *QtFlagPropertyManager::subBoolPropertyManager() const {
  return d_ptr->m_boolPropertyManager;
}

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

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

    \sa flagNames(), setValue()
*/
int QtFlagPropertyManager::value(const QtProperty *property) const {
  return getValue<int>(d_ptr->m_values, property, 0);
}

/**
    Returns the given \a property's list of flag names.

    \sa value(), setFlagNames()
*/
QStringList QtFlagPropertyManager::flagNames(const QtProperty *property) const {
  return getData<QStringList>(d_ptr->m_values,
                              &QtFlagPropertyManagerPrivate::Data::flagNames,
                              property, QStringList());
}

/**
    \reimp
*/
QString QtFlagPropertyManager::valueText(const QtProperty *property) const {
  const QtFlagPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();

  const QtFlagPropertyManagerPrivate::Data &data = it.value();

  QString str;
  int level = 0;
  const QChar bar = QLatin1Char('|');
  const QStringList::const_iterator fncend = data.flagNames.constEnd();
  for (QStringList::const_iterator it = data.flagNames.constBegin();
       it != fncend; ++it) {
    if (data.val & (1 << level)) {
      if (!str.isEmpty())
        str += bar;
      str += *it;
    }

    level++;
  }
  return str;
}

/**
    \fn void QtFlagPropertyManager::setValue(QtProperty *property, int value)

    Sets the value of the given \a property to \a value. Nested
    properties are updated automatically.

    The specified \a value must be less than the binary combination of
    the property's flagNames() list size (i.e. less than 2\sup n,
    where \c n is the size of the list) and larger than (or equal to)
    0.

    \sa value(), valueChanged()
*/
void QtFlagPropertyManager::setValue(QtProperty *property, int val) {
  const QtFlagPropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

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

  if (data.val == val)
    return;

  if (val > (1 << data.flagNames.count()) - 1)
    return;

  if (val < 0)
    return;

  data.val = val;

  it.value() = data;

  QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
  int level = 0;
  while (itProp.hasNext()) {
    QtProperty *prop = itProp.next();
    if (prop)
      d_ptr->m_boolPropertyManager->setValue(prop, val & (1 << level));
    level++;
  }

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

/**
    Sets the given \a property's list of flag names to \a flagNames. The
    property's current value is reset to 0 indicating the first item
    of the list.

    \sa flagNames(), flagNamesChanged()
*/
void QtFlagPropertyManager::setFlagNames(QtProperty *property,
                                         const QStringList &flagNames) {
  const QtFlagPropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

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

  if (data.flagNames == flagNames)
    return;

  data.flagNames = flagNames;
  data.val = 0;

  it.value() = data;

  QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
  while (itProp.hasNext()) {
    QtProperty *prop = itProp.next();
    if (prop) {
      delete prop;
      d_ptr->m_flagToProperty.remove(prop);
    }
  }
  d_ptr->m_propertyToFlags[property].clear();

  QStringListIterator itFlag(flagNames);
  while (itFlag.hasNext()) {
    const QString flagName = itFlag.next();
    QtProperty *prop = d_ptr->m_boolPropertyManager->addProperty();
    prop->setPropertyName(flagName);
    property->addSubProperty(prop);
    d_ptr->m_propertyToFlags[property].append(prop);
    d_ptr->m_flagToProperty[prop] = property;
  }

  emit flagNamesChanged(property, data.flagNames);

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

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

  d_ptr->m_propertyToFlags[property] = QList<QtProperty *>();
}

/**
    \reimp
*/
void QtFlagPropertyManager::uninitializeProperty(QtProperty *property) {
  QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
  while (itProp.hasNext()) {
    QtProperty *prop = itProp.next();
    if (prop) {
      delete prop;
      d_ptr->m_flagToProperty.remove(prop);
    }
  }
  d_ptr->m_propertyToFlags.remove(property);

  d_ptr->m_values.remove(property);
}

// QtSizePolicyPropertyManager

class QtSizePolicyPropertyManagerPrivate {
  QtSizePolicyPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtSizePolicyPropertyManager)
public:
  QtSizePolicyPropertyManagerPrivate();

  void slotIntChanged(QtProperty *property, int value);
  void slotEnumChanged(QtProperty *property, int value);
  void slotPropertyDestroyed(QtProperty *property);

  typedef QMap<const QtProperty *, QSizePolicy> PropertyValueMap;
  PropertyValueMap m_values;

  QtIntPropertyManager *m_intPropertyManager;
  QtEnumPropertyManager *m_enumPropertyManager;

  QMap<const QtProperty *, QtProperty *> m_propertyToHPolicy;
  QMap<const QtProperty *, QtProperty *> m_propertyToVPolicy;
  QMap<const QtProperty *, QtProperty *> m_propertyToHStretch;
  QMap<const QtProperty *, QtProperty *> m_propertyToVStretch;

  QMap<const QtProperty *, QtProperty *> m_hPolicyToProperty;
  QMap<const QtProperty *, QtProperty *> m_vPolicyToProperty;
  QMap<const QtProperty *, QtProperty *> m_hStretchToProperty;
  QMap<const QtProperty *, QtProperty *> m_vStretchToProperty;
};

QtSizePolicyPropertyManagerPrivate::QtSizePolicyPropertyManagerPrivate() {}

void QtSizePolicyPropertyManagerPrivate::slotIntChanged(QtProperty *property,
                                                        int value) {
  if (QtProperty *prop = m_hStretchToProperty.value(property, 0)) {
    QSizePolicy sp = m_values[prop];
    sp.setHorizontalStretch(static_cast<uchar>(value));
    q_ptr->setValue(prop, sp);
  } else if (QtProperty *prop = m_vStretchToProperty.value(property, 0)) {
    QSizePolicy sp = m_values[prop];
    sp.setVerticalStretch(static_cast<uchar>(value));
    q_ptr->setValue(prop, sp);
  }
}

void QtSizePolicyPropertyManagerPrivate::slotEnumChanged(QtProperty *property,
                                                         int value) {
  if (QtProperty *prop = m_hPolicyToProperty.value(property, 0)) {
    QSizePolicy sp = m_values[prop];
    sp.setHorizontalPolicy(metaEnumProvider()->indexToSizePolicy(value));
    q_ptr->setValue(prop, sp);
  } else if (QtProperty *prop = m_vPolicyToProperty.value(property, 0)) {
    QSizePolicy sp = m_values[prop];
    sp.setVerticalPolicy(metaEnumProvider()->indexToSizePolicy(value));
    q_ptr->setValue(prop, sp);
  }
}

void QtSizePolicyPropertyManagerPrivate::slotPropertyDestroyed(
    QtProperty *property) {
  if (QtProperty *pointProp = m_hStretchToProperty.value(property, 0)) {
    m_propertyToHStretch[pointProp] = 0;
    m_hStretchToProperty.remove(property);
  } else if (QtProperty *pointProp = m_vStretchToProperty.value(property, 0)) {
    m_propertyToVStretch[pointProp] = 0;
    m_vStretchToProperty.remove(property);
  } else if (QtProperty *pointProp = m_hPolicyToProperty.value(property, 0)) {
    m_propertyToHPolicy[pointProp] = 0;
    m_hPolicyToProperty.remove(property);
  } else if (QtProperty *pointProp = m_vPolicyToProperty.value(property, 0)) {
    m_propertyToVPolicy[pointProp] = 0;
    m_vPolicyToProperty.remove(property);
  }
}

/**
    \class QtSizePolicyPropertyManager

    \brief The QtSizePolicyPropertyManager provides and manages QSizePolicy
   properties.

    A size policy property has nested \e horizontalPolicy, \e
    verticalPolicy, \e horizontalStretch and \e verticalStretch
    subproperties. The top-level property's value can be retrieved
    using the value() function, and set using the setValue() slot.

    The subproperties are created by QtIntPropertyManager and
   QtEnumPropertyManager
    objects. These managers can be retrieved using the subIntPropertyManager()
    and subEnumPropertyManager() functions respectively. In order to provide
    editing widgets for the subproperties in a property browser widget,
    these managers must be associated with editor factories.

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

    \sa QtAbstractPropertyManager, QtIntPropertyManager, QtEnumPropertyManager
*/

/**
    \fn void QtSizePolicyPropertyManager::valueChanged(QtProperty *property,
   const QSizePolicy &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.
*/
QtSizePolicyPropertyManager::QtSizePolicyPropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtSizePolicyPropertyManagerPrivate;
  d_ptr->q_ptr = this;

  d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
  connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
          this, SLOT(slotIntChanged(QtProperty *, int)));
  d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
  connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
          this, SLOT(slotEnumChanged(QtProperty *, int)));

  connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
  connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
}

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

/**
    Returns the manager that creates the nested \e horizontalStretch
    and \e verticalStretch subproperties.

    In order to provide editing widgets for the mentioned subproperties
    in a property browser widget, this manager must be associated with
    an editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtIntPropertyManager *
QtSizePolicyPropertyManager::subIntPropertyManager() const {
  return d_ptr->m_intPropertyManager;
}

/**
    Returns the manager that creates the nested \e horizontalPolicy
    and \e verticalPolicy subproperties.

    In order to provide editing widgets for the mentioned subproperties
    in a property browser widget, this manager must be associated with
    an editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtEnumPropertyManager *
QtSizePolicyPropertyManager::subEnumPropertyManager() const {
  return d_ptr->m_enumPropertyManager;
}

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

    If the given property is not managed by this manager, this
    function returns the default size policy.

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

/**
    \reimp
*/
QString
QtSizePolicyPropertyManager::valueText(const QtProperty *property) const {
  const QtSizePolicyPropertyManagerPrivate::PropertyValueMap::const_iterator
      it = d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();

  const QSizePolicy sp = it.value();
  const QtMetaEnumProvider *mep = metaEnumProvider();
  const int hIndex = mep->sizePolicyToIndex(sp.horizontalPolicy());
  const int vIndex = mep->sizePolicyToIndex(sp.verticalPolicy());
  //! Unknown size policy on reading invalid uic3 files
  const QString hPolicy =
      hIndex != -1 ? mep->policyEnumNames().at(hIndex) : tr("<Invalid>");
  const QString vPolicy =
      vIndex != -1 ? mep->policyEnumNames().at(vIndex) : tr("<Invalid>");
  const QString str = tr("[%1, %2, %3, %4]")
                          .arg(hPolicy, vPolicy)
                          .arg(sp.horizontalStretch())
                          .arg(sp.verticalStretch());
  return str;
}

/**
    \fn void QtSizePolicyPropertyManager::setValue(QtProperty *property, const
   QSizePolicy &value)

    Sets the value of the given \a property to \a value. Nested
    properties are updated automatically.

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

  if (it.value() == val)
    return;

  it.value() = val;

  d_ptr->m_enumPropertyManager->setValue(
      d_ptr->m_propertyToHPolicy[property],
      metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
  d_ptr->m_enumPropertyManager->setValue(
      d_ptr->m_propertyToVPolicy[property],
      metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToHStretch[property],
                                        val.horizontalStretch());
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToVStretch[property],
                                        val.verticalStretch());

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

/**
    \reimp
*/
void QtSizePolicyPropertyManager::initializeProperty(QtProperty *property) {
  QSizePolicy val;
  d_ptr->m_values[property] = val;

  QtProperty *hPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
  hPolicyProp->setPropertyName(tr("Horizontal Policy"));
  d_ptr->m_enumPropertyManager->setEnumNames(
      hPolicyProp, metaEnumProvider()->policyEnumNames());
  d_ptr->m_enumPropertyManager->setValue(
      hPolicyProp,
      metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
  d_ptr->m_propertyToHPolicy[property] = hPolicyProp;
  d_ptr->m_hPolicyToProperty[hPolicyProp] = property;
  property->addSubProperty(hPolicyProp);

  QtProperty *vPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
  vPolicyProp->setPropertyName(tr("Vertical Policy"));
  d_ptr->m_enumPropertyManager->setEnumNames(
      vPolicyProp, metaEnumProvider()->policyEnumNames());
  d_ptr->m_enumPropertyManager->setValue(
      vPolicyProp, metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
  d_ptr->m_propertyToVPolicy[property] = vPolicyProp;
  d_ptr->m_vPolicyToProperty[vPolicyProp] = property;
  property->addSubProperty(vPolicyProp);

  QtProperty *hStretchProp = d_ptr->m_intPropertyManager->addProperty();
  hStretchProp->setPropertyName(tr("Horizontal Stretch"));
  d_ptr->m_intPropertyManager->setValue(hStretchProp, val.horizontalStretch());
  d_ptr->m_intPropertyManager->setRange(hStretchProp, 0, 0xff);
  d_ptr->m_propertyToHStretch[property] = hStretchProp;
  d_ptr->m_hStretchToProperty[hStretchProp] = property;
  property->addSubProperty(hStretchProp);

  QtProperty *vStretchProp = d_ptr->m_intPropertyManager->addProperty();
  vStretchProp->setPropertyName(tr("Vertical Stretch"));
  d_ptr->m_intPropertyManager->setValue(vStretchProp, val.verticalStretch());
  d_ptr->m_intPropertyManager->setRange(vStretchProp, 0, 0xff);
  d_ptr->m_propertyToVStretch[property] = vStretchProp;
  d_ptr->m_vStretchToProperty[vStretchProp] = property;
  property->addSubProperty(vStretchProp);
}

/**
    \reimp
*/
void QtSizePolicyPropertyManager::uninitializeProperty(QtProperty *property) {
  QtProperty *hPolicyProp = d_ptr->m_propertyToHPolicy[property];
  if (hPolicyProp) {
    d_ptr->m_hPolicyToProperty.remove(hPolicyProp);
    delete hPolicyProp;
  }
  d_ptr->m_propertyToHPolicy.remove(property);

  QtProperty *vPolicyProp = d_ptr->m_propertyToVPolicy[property];
  if (vPolicyProp) {
    d_ptr->m_vPolicyToProperty.remove(vPolicyProp);
    delete vPolicyProp;
  }
  d_ptr->m_propertyToVPolicy.remove(property);

  QtProperty *hStretchProp = d_ptr->m_propertyToHStretch[property];
  if (hStretchProp) {
    d_ptr->m_hStretchToProperty.remove(hStretchProp);
    delete hStretchProp;
  }
  d_ptr->m_propertyToHStretch.remove(property);

  QtProperty *vStretchProp = d_ptr->m_propertyToVStretch[property];
  if (vStretchProp) {
    d_ptr->m_vStretchToProperty.remove(vStretchProp);
    delete vStretchProp;
  }
  d_ptr->m_propertyToVStretch.remove(property);

  d_ptr->m_values.remove(property);
}

// QtFontPropertyManager:
// QtFontPropertyManagerPrivate has a mechanism for reacting
// to QApplication::fontDatabaseChanged() [4.5], which is emitted
// when someone loads an application font. The signals are compressed
// using a timer with interval 0, which then causes the family
// enumeration manager to re-set its strings and index values
// for each property.

Q_GLOBAL_STATIC(QFontDatabase, fontDatabase)

class QtFontPropertyManagerPrivate {
  QtFontPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtFontPropertyManager)
public:
  QtFontPropertyManagerPrivate();

  void slotIntChanged(QtProperty *property, int value);
  void slotEnumChanged(QtProperty *property, int value);
  void slotBoolChanged(QtProperty *property, bool value);
  void slotPropertyDestroyed(QtProperty *property);
  void slotFontDatabaseChanged();
  void slotFontDatabaseDelayedChange();

  QStringList m_familyNames;

  typedef QMap<const QtProperty *, QFont> PropertyValueMap;
  PropertyValueMap m_values;

  QtIntPropertyManager *m_intPropertyManager;
  QtEnumPropertyManager *m_enumPropertyManager;
  QtBoolPropertyManager *m_boolPropertyManager;

  QMap<const QtProperty *, QtProperty *> m_propertyToFamily;
  QMap<const QtProperty *, QtProperty *> m_propertyToPointSize;
  QMap<const QtProperty *, QtProperty *> m_propertyToBold;
  QMap<const QtProperty *, QtProperty *> m_propertyToItalic;
  QMap<const QtProperty *, QtProperty *> m_propertyToUnderline;
  QMap<const QtProperty *, QtProperty *> m_propertyToStrikeOut;
  QMap<const QtProperty *, QtProperty *> m_propertyToKerning;

  QMap<const QtProperty *, QtProperty *> m_familyToProperty;
  QMap<const QtProperty *, QtProperty *> m_pointSizeToProperty;
  QMap<const QtProperty *, QtProperty *> m_boldToProperty;
  QMap<const QtProperty *, QtProperty *> m_italicToProperty;
  QMap<const QtProperty *, QtProperty *> m_underlineToProperty;
  QMap<const QtProperty *, QtProperty *> m_strikeOutToProperty;
  QMap<const QtProperty *, QtProperty *> m_kerningToProperty;

  bool m_settingValue;
  QTimer *m_fontDatabaseChangeTimer;
};

QtFontPropertyManagerPrivate::QtFontPropertyManagerPrivate()
    : m_settingValue(false), m_fontDatabaseChangeTimer(0) {}

void QtFontPropertyManagerPrivate::slotIntChanged(QtProperty *property,
                                                  int value) {
  if (m_settingValue)
    return;
  if (QtProperty *prop = m_pointSizeToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setPointSize(value);
    q_ptr->setValue(prop, f);
  }
}

void QtFontPropertyManagerPrivate::slotEnumChanged(QtProperty *property,
                                                   int value) {
  if (m_settingValue)
    return;
  if (QtProperty *prop = m_familyToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setFamily(m_familyNames.at(value));
    q_ptr->setValue(prop, f);
  }
}

void QtFontPropertyManagerPrivate::slotBoolChanged(QtProperty *property,
                                                   bool value) {
  if (m_settingValue)
    return;
  if (QtProperty *prop = m_boldToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setBold(value);
    q_ptr->setValue(prop, f);
  } else if (QtProperty *prop = m_italicToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setItalic(value);
    q_ptr->setValue(prop, f);
  } else if (QtProperty *prop = m_underlineToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setUnderline(value);
    q_ptr->setValue(prop, f);
  } else if (QtProperty *prop = m_strikeOutToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setStrikeOut(value);
    q_ptr->setValue(prop, f);
  } else if (QtProperty *prop = m_kerningToProperty.value(property, 0)) {
    QFont f = m_values[prop];
    f.setKerning(value);
    q_ptr->setValue(prop, f);
  }
}

void QtFontPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property) {
  if (QtProperty *pointProp = m_pointSizeToProperty.value(property, 0)) {
    m_propertyToPointSize[pointProp] = 0;
    m_pointSizeToProperty.remove(property);
  } else if (QtProperty *pointProp = m_familyToProperty.value(property, 0)) {
    m_propertyToFamily[pointProp] = 0;
    m_familyToProperty.remove(property);
  } else if (QtProperty *pointProp = m_boldToProperty.value(property, 0)) {
    m_propertyToBold[pointProp] = 0;
    m_boldToProperty.remove(property);
  } else if (QtProperty *pointProp = m_italicToProperty.value(property, 0)) {
    m_propertyToItalic[pointProp] = 0;
    m_italicToProperty.remove(property);
  } else if (QtProperty *pointProp = m_underlineToProperty.value(property, 0)) {
    m_propertyToUnderline[pointProp] = 0;
    m_underlineToProperty.remove(property);
  } else if (QtProperty *pointProp = m_strikeOutToProperty.value(property, 0)) {
    m_propertyToStrikeOut[pointProp] = 0;
    m_strikeOutToProperty.remove(property);
  } else if (QtProperty *pointProp = m_kerningToProperty.value(property, 0)) {
    m_propertyToKerning[pointProp] = 0;
    m_kerningToProperty.remove(property);
  }
}

void QtFontPropertyManagerPrivate::slotFontDatabaseChanged() {
  if (!m_fontDatabaseChangeTimer) {
    m_fontDatabaseChangeTimer = new QTimer(q_ptr);
    m_fontDatabaseChangeTimer->setInterval(0);
    m_fontDatabaseChangeTimer->setSingleShot(true);
    QObject::connect(m_fontDatabaseChangeTimer, SIGNAL(timeout()), q_ptr,
                     SLOT(slotFontDatabaseDelayedChange()));
  }
  if (!m_fontDatabaseChangeTimer->isActive())
    m_fontDatabaseChangeTimer->start();
}

void QtFontPropertyManagerPrivate::slotFontDatabaseDelayedChange() {
  typedef QMap<const QtProperty *, QtProperty *> PropertyPropertyMap;
  // rescan available font names
  const QStringList oldFamilies = m_familyNames;
  m_familyNames = fontDatabase()->families();

  // Adapt all existing properties
  if (!m_propertyToFamily.empty()) {
    PropertyPropertyMap::const_iterator cend = m_propertyToFamily.constEnd();
    for (PropertyPropertyMap::const_iterator it =
             m_propertyToFamily.constBegin();
         it != cend; ++it) {
      QtProperty *familyProp = it.value();
      const int oldIdx = m_enumPropertyManager->value(familyProp);
      int newIdx = m_familyNames.indexOf(oldFamilies.at(oldIdx));
      if (newIdx < 0)
        newIdx = 0;
      m_enumPropertyManager->setEnumNames(familyProp, m_familyNames);
      m_enumPropertyManager->setValue(familyProp, newIdx);
    }
  }
}

/**
    \class QtFontPropertyManager

    \brief The QtFontPropertyManager provides and manages QFont properties.

    A font property has nested \e family, \e pointSize, \e bold, \e
    italic, \e underline, \e strikeOut and \e kerning subproperties. The
   top-level
    property's value can be retrieved using the value() function, and
    set using the setValue() slot.

    The subproperties are created by QtIntPropertyManager, QtEnumPropertyManager
   and
    QtBoolPropertyManager objects. These managers can be retrieved using the
    corresponding subIntPropertyManager(), subEnumPropertyManager() and
    subBoolPropertyManager() functions. In order to provide editing widgets
    for the subproperties in a property browser widget, these managers
    must be associated with editor factories.

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

    \sa QtAbstractPropertyManager, QtEnumPropertyManager, QtIntPropertyManager,
   QtBoolPropertyManager
*/

/**
    \fn void QtFontPropertyManager::valueChanged(QtProperty *property, const
   QFont &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.
*/
QtFontPropertyManager::QtFontPropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtFontPropertyManagerPrivate;
  d_ptr->q_ptr = this;
#if QT_VERSION >= 0x040500
  QObject::connect(qApp, SIGNAL(fontDatabaseChanged()), this,
                   SLOT(slotFontDatabaseChanged()));
#endif

  d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
  connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
          this, SLOT(slotIntChanged(QtProperty *, int)));
  d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
  connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
          this, SLOT(slotEnumChanged(QtProperty *, int)));
  d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
  connect(d_ptr->m_boolPropertyManager,
          SIGNAL(valueChanged(QtProperty *, bool)), this,
          SLOT(slotBoolChanged(QtProperty *, bool)));

  connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
  connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
  connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
          this, SLOT(slotPropertyDestroyed(QtProperty *)));
}

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

/**
    Returns the manager that creates the \e pointSize subproperty.

    In order to provide editing widgets for the \e pointSize property
    in a property browser widget, this manager must be associated
    with an editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtIntPropertyManager *QtFontPropertyManager::subIntPropertyManager() const {
  return d_ptr->m_intPropertyManager;
}

/**
    Returns the manager that create the \e family subproperty.

    In order to provide editing widgets for the \e family property
    in a property browser widget, this manager must be associated
    with an editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtEnumPropertyManager *QtFontPropertyManager::subEnumPropertyManager() const {
  return d_ptr->m_enumPropertyManager;
}

/**
    Returns the manager that creates the  \e bold, \e italic, \e underline,
    \e strikeOut and \e kerning subproperties.

    In order to provide editing widgets for the mentioned properties
    in a property browser widget, this manager must be associated with
    an editor factory.

    \sa QtAbstractPropertyBrowser::setFactoryForManager()
*/
QtBoolPropertyManager *QtFontPropertyManager::subBoolPropertyManager() const {
  return d_ptr->m_boolPropertyManager;
}

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

    If the given property is not managed by this manager, this
    function returns a font object that uses the application's default
    font.

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

/**
    \reimp
*/
QString QtFontPropertyManager::valueText(const QtProperty *property) const {
  const QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();

  return QtPropertyBrowserUtils::fontValueText(it.value());
}

/**
    \reimp
*/
QIcon QtFontPropertyManager::valueIcon(const QtProperty *property) const {
  const QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QIcon();

  return QtPropertyBrowserUtils::fontValueIcon(it.value());
}

/**
    \fn void QtFontPropertyManager::setValue(QtProperty *property, const QFont
   &value)

    Sets the value of the given \a property to \a value. Nested
    properties are updated automatically.

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

  const QFont oldVal = it.value();
  if (oldVal == val && oldVal.resolve() == val.resolve())
    return;

  it.value() = val;

  int idx = d_ptr->m_familyNames.indexOf(val.family());
  if (idx == -1)
    idx = 0;
  bool settingValue = d_ptr->m_settingValue;
  d_ptr->m_settingValue = true;
  d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToFamily[property],
                                         idx);
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToPointSize[property],
                                        val.pointSize());
  d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToBold[property],
                                         val.bold());
  d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToItalic[property],
                                         val.italic());
  d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToUnderline[property],
                                         val.underline());
  d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToStrikeOut[property],
                                         val.strikeOut());
  d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToKerning[property],
                                         val.kerning());
  d_ptr->m_settingValue = settingValue;

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

/**
    \reimp
*/
void QtFontPropertyManager::initializeProperty(QtProperty *property) {
  QFont val;
  d_ptr->m_values[property] = val;

  QtProperty *familyProp = d_ptr->m_enumPropertyManager->addProperty();
  familyProp->setPropertyName(tr("Family"));
  if (d_ptr->m_familyNames.empty())
    d_ptr->m_familyNames = fontDatabase()->families();