qtpropertymanager.cpp

  d_ptr->m_enumPropertyManager->setEnumNames(familyProp, d_ptr->m_familyNames);
  int idx = d_ptr->m_familyNames.indexOf(val.family());
  if (idx == -1)
    idx = 0;
  d_ptr->m_enumPropertyManager->setValue(familyProp, idx);
  d_ptr->m_propertyToFamily[property] = familyProp;
  d_ptr->m_familyToProperty[familyProp] = property;
  property->addSubProperty(familyProp);

  QtProperty *pointSizeProp = d_ptr->m_intPropertyManager->addProperty();
  pointSizeProp->setPropertyName(tr("Point Size"));
  d_ptr->m_intPropertyManager->setValue(pointSizeProp, val.pointSize());
  d_ptr->m_intPropertyManager->setMinimum(pointSizeProp, 1);
  d_ptr->m_propertyToPointSize[property] = pointSizeProp;
  d_ptr->m_pointSizeToProperty[pointSizeProp] = property;
  property->addSubProperty(pointSizeProp);

  QtProperty *boldProp = d_ptr->m_boolPropertyManager->addProperty();
  boldProp->setPropertyName(tr("Bold"));
  d_ptr->m_boolPropertyManager->setValue(boldProp, val.bold());
  d_ptr->m_propertyToBold[property] = boldProp;
  d_ptr->m_boldToProperty[boldProp] = property;
  property->addSubProperty(boldProp);

  QtProperty *italicProp = d_ptr->m_boolPropertyManager->addProperty();
  italicProp->setPropertyName(tr("Italic"));
  d_ptr->m_boolPropertyManager->setValue(italicProp, val.italic());
  d_ptr->m_propertyToItalic[property] = italicProp;
  d_ptr->m_italicToProperty[italicProp] = property;
  property->addSubProperty(italicProp);

  QtProperty *underlineProp = d_ptr->m_boolPropertyManager->addProperty();
  underlineProp->setPropertyName(tr("Underline"));
  d_ptr->m_boolPropertyManager->setValue(underlineProp, val.underline());
  d_ptr->m_propertyToUnderline[property] = underlineProp;
  d_ptr->m_underlineToProperty[underlineProp] = property;
  property->addSubProperty(underlineProp);

  QtProperty *strikeOutProp = d_ptr->m_boolPropertyManager->addProperty();
  strikeOutProp->setPropertyName(tr("Strikeout"));
  d_ptr->m_boolPropertyManager->setValue(strikeOutProp, val.strikeOut());
  d_ptr->m_propertyToStrikeOut[property] = strikeOutProp;
  d_ptr->m_strikeOutToProperty[strikeOutProp] = property;
  property->addSubProperty(strikeOutProp);

  QtProperty *kerningProp = d_ptr->m_boolPropertyManager->addProperty();
  kerningProp->setPropertyName(tr("Kerning"));
  d_ptr->m_boolPropertyManager->setValue(kerningProp, val.kerning());
  d_ptr->m_propertyToKerning[property] = kerningProp;
  d_ptr->m_kerningToProperty[kerningProp] = property;
  property->addSubProperty(kerningProp);
}

/**
    \reimp
*/
void QtFontPropertyManager::uninitializeProperty(QtProperty *property) {
  QtProperty *familyProp = d_ptr->m_propertyToFamily[property];
  if (familyProp) {
    d_ptr->m_familyToProperty.remove(familyProp);
    delete familyProp;
  }
  d_ptr->m_propertyToFamily.remove(property);

  QtProperty *pointSizeProp = d_ptr->m_propertyToPointSize[property];
  if (pointSizeProp) {
    d_ptr->m_pointSizeToProperty.remove(pointSizeProp);
    delete pointSizeProp;
  }
  d_ptr->m_propertyToPointSize.remove(property);

  QtProperty *boldProp = d_ptr->m_propertyToBold[property];
  if (boldProp) {
    d_ptr->m_boldToProperty.remove(boldProp);
    delete boldProp;
  }
  d_ptr->m_propertyToBold.remove(property);

  QtProperty *italicProp = d_ptr->m_propertyToItalic[property];
  if (italicProp) {
    d_ptr->m_italicToProperty.remove(italicProp);
    delete italicProp;
  }
  d_ptr->m_propertyToItalic.remove(property);

  QtProperty *underlineProp = d_ptr->m_propertyToUnderline[property];
  if (underlineProp) {
    d_ptr->m_underlineToProperty.remove(underlineProp);
    delete underlineProp;
  }
  d_ptr->m_propertyToUnderline.remove(property);

  QtProperty *strikeOutProp = d_ptr->m_propertyToStrikeOut[property];
  if (strikeOutProp) {
    d_ptr->m_strikeOutToProperty.remove(strikeOutProp);
    delete strikeOutProp;
  }
  d_ptr->m_propertyToStrikeOut.remove(property);

  QtProperty *kerningProp = d_ptr->m_propertyToKerning[property];
  if (kerningProp) {
    d_ptr->m_kerningToProperty.remove(kerningProp);
    delete kerningProp;
  }
  d_ptr->m_propertyToKerning.remove(property);

  d_ptr->m_values.remove(property);
}

// QtColorPropertyManager

class QtColorPropertyManagerPrivate {
  QtColorPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtColorPropertyManager)
public:
  void slotIntChanged(QtProperty *property, int value);
  void slotPropertyDestroyed(QtProperty *property);

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

  QtIntPropertyManager *m_intPropertyManager;

  QMap<const QtProperty *, QtProperty *> m_propertyToR;
  QMap<const QtProperty *, QtProperty *> m_propertyToG;
  QMap<const QtProperty *, QtProperty *> m_propertyToB;
  QMap<const QtProperty *, QtProperty *> m_propertyToA;

  QMap<const QtProperty *, QtProperty *> m_rToProperty;
  QMap<const QtProperty *, QtProperty *> m_gToProperty;
  QMap<const QtProperty *, QtProperty *> m_bToProperty;
  QMap<const QtProperty *, QtProperty *> m_aToProperty;
};

void QtColorPropertyManagerPrivate::slotIntChanged(QtProperty *property,
                                                   int value) {
  if (QtProperty *prop = m_rToProperty.value(property, 0)) {
    QColor c = m_values[prop];
    c.setRed(value);
    q_ptr->setValue(prop, c);
  } else if (QtProperty *prop = m_gToProperty.value(property, 0)) {
    QColor c = m_values[prop];
    c.setGreen(value);
    q_ptr->setValue(prop, c);
  } else if (QtProperty *prop = m_bToProperty.value(property, 0)) {
    QColor c = m_values[prop];
    c.setBlue(value);
    q_ptr->setValue(prop, c);
  } else if (QtProperty *prop = m_aToProperty.value(property, 0)) {
    QColor c = m_values[prop];
    c.setAlpha(value);
    q_ptr->setValue(prop, c);
  }
}

void QtColorPropertyManagerPrivate::slotPropertyDestroyed(
    QtProperty *property) {
  if (QtProperty *pointProp = m_rToProperty.value(property, 0)) {
    m_propertyToR[pointProp] = 0;
    m_rToProperty.remove(property);
  } else if (QtProperty *pointProp = m_gToProperty.value(property, 0)) {
    m_propertyToG[pointProp] = 0;
    m_gToProperty.remove(property);
  } else if (QtProperty *pointProp = m_bToProperty.value(property, 0)) {
    m_propertyToB[pointProp] = 0;
    m_bToProperty.remove(property);
  } else if (QtProperty *pointProp = m_aToProperty.value(property, 0)) {
    m_propertyToA[pointProp] = 0;
    m_aToProperty.remove(property);
  }
}

/**
    \class QtColorPropertyManager

    \brief The QtColorPropertyManager provides and manages QColor properties.

    A color property has nested \e red, \e green and \e blue
    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 a QtIntPropertyManager object. This
    manager can be retrieved using the subIntPropertyManager() 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, QtColorPropertyManager provides the valueChanged() signal
    which is emitted whenever a property created by this manager
    changes.

    \sa QtAbstractPropertyManager, QtAbstractPropertyBrowser,
   QtIntPropertyManager
*/

/**
    \fn void QtColorPropertyManager::valueChanged(QtProperty *property, const
   QColor &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.
*/
QtColorPropertyManager::QtColorPropertyManager(QObject *parent)
    : QtAbstractPropertyManager(parent) {
  d_ptr = new QtColorPropertyManagerPrivate;
  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)));

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

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

/**
    Returns the manager that produces the nested \e red, \e green and
    \e blue subproperties.

    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()
*/
QtIntPropertyManager *QtColorPropertyManager::subIntPropertyManager() const {
  return d_ptr->m_intPropertyManager;
}

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

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

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

/**
    \reimp
*/

QString QtColorPropertyManager::valueText(const QtProperty *property) const {
  const QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QString();

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

/**
    \reimp
*/

QIcon QtColorPropertyManager::valueIcon(const QtProperty *property) const {
  const QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it =
      d_ptr->m_values.constFind(property);
  if (it == d_ptr->m_values.constEnd())
    return QIcon();
  return QtPropertyBrowserUtils::brushValueIcon(QBrush(it.value()));
}

/**
    \fn void QtColorPropertyManager::setValue(QtProperty *property, const QColor
   &value)

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

    \sa value(), valueChanged()
*/
void QtColorPropertyManager::setValue(QtProperty *property, const QColor &val) {
  const QtColorPropertyManagerPrivate::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_intPropertyManager->setValue(d_ptr->m_propertyToR[property],
                                        val.red());
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToG[property],
                                        val.green());
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToB[property],
                                        val.blue());
  d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToA[property],
                                        val.alpha());

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

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

  QtProperty *rProp = d_ptr->m_intPropertyManager->addProperty();
  rProp->setPropertyName(tr("Red"));
  d_ptr->m_intPropertyManager->setValue(rProp, val.red());
  d_ptr->m_intPropertyManager->setRange(rProp, 0, 0xFF);
  d_ptr->m_propertyToR[property] = rProp;
  d_ptr->m_rToProperty[rProp] = property;
  property->addSubProperty(rProp);

  QtProperty *gProp = d_ptr->m_intPropertyManager->addProperty();
  gProp->setPropertyName(tr("Green"));
  d_ptr->m_intPropertyManager->setValue(gProp, val.green());
  d_ptr->m_intPropertyManager->setRange(gProp, 0, 0xFF);
  d_ptr->m_propertyToG[property] = gProp;
  d_ptr->m_gToProperty[gProp] = property;
  property->addSubProperty(gProp);

  QtProperty *bProp = d_ptr->m_intPropertyManager->addProperty();
  bProp->setPropertyName(tr("Blue"));
  d_ptr->m_intPropertyManager->setValue(bProp, val.blue());
  d_ptr->m_intPropertyManager->setRange(bProp, 0, 0xFF);
  d_ptr->m_propertyToB[property] = bProp;
  d_ptr->m_bToProperty[bProp] = property;
  property->addSubProperty(bProp);

  QtProperty *aProp = d_ptr->m_intPropertyManager->addProperty();
  aProp->setPropertyName(tr("Alpha"));
  d_ptr->m_intPropertyManager->setValue(aProp, val.alpha());
  d_ptr->m_intPropertyManager->setRange(aProp, 0, 0xFF);
  d_ptr->m_propertyToA[property] = aProp;
  d_ptr->m_aToProperty[aProp] = property;
  property->addSubProperty(aProp);
}

/**
    \reimp
*/
void QtColorPropertyManager::uninitializeProperty(QtProperty *property) {
  QtProperty *rProp = d_ptr->m_propertyToR[property];
  if (rProp) {
    d_ptr->m_rToProperty.remove(rProp);
    delete rProp;
  }
  d_ptr->m_propertyToR.remove(property);

  QtProperty *gProp = d_ptr->m_propertyToG[property];
  if (gProp) {
    d_ptr->m_gToProperty.remove(gProp);
    delete gProp;
  }
  d_ptr->m_propertyToG.remove(property);

  QtProperty *bProp = d_ptr->m_propertyToB[property];
  if (bProp) {
    d_ptr->m_bToProperty.remove(bProp);
    delete bProp;
  }
  d_ptr->m_propertyToB.remove(property);

  QtProperty *aProp = d_ptr->m_propertyToA[property];
  if (aProp) {
    d_ptr->m_aToProperty.remove(aProp);
    delete aProp;
  }
  d_ptr->m_propertyToA.remove(property);

  d_ptr->m_values.remove(property);
}

// QtCursorPropertyManager

Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)

class QtCursorPropertyManagerPrivate {
  QtCursorPropertyManager *q_ptr;
  Q_DECLARE_PUBLIC(QtCursorPropertyManager)
public:
  typedef QMap<const QtProperty *, QCursor> PropertyValueMap;
  PropertyValueMap m_values;
};

/**
    \class QtCursorPropertyManager

    \brief The QtCursorPropertyManager provides and manages QCursor properties.

    A cursor property has a current value which can be
    retrieved using the value() function, and set using the setValue()
    slot. In addition, QtCursorPropertyManager provides the
    valueChanged() signal which is emitted whenever a property created
    by this manager changes.

    \sa QtAbstractPropertyManager
*/

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

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

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

    If the given \a property is not managed by this manager, this
    function returns a default QCursor object.

    \sa setValue()
*/
#ifndef QT_NO_CURSOR
QCursor QtCursorPropertyManager::value(const QtProperty *property) const {
  return d_ptr->m_values.value(property, QCursor());
}
#endif

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

  return cursorDatabase()->cursorToShapeName(it.value());
}

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

  return cursorDatabase()->cursorToShapeIcon(it.value());
}

/**
    \fn void QtCursorPropertyManager::setValue(QtProperty *property, const
   QCursor &value)

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

    \sa value(), valueChanged()
*/
void QtCursorPropertyManager::setValue(QtProperty *property,
                                       const QCursor &value) {
#ifndef QT_NO_CURSOR
  const QtCursorPropertyManagerPrivate::PropertyValueMap::iterator it =
      d_ptr->m_values.find(property);
  if (it == d_ptr->m_values.end())
    return;

  if (it.value().shape() == value.shape() && value.shape() != Qt::BitmapCursor)
    return;

  it.value() = value;

  emit propertyChanged(property);
  emit valueChanged(property, value);
#endif
}

/**
    \reimp
*/
void QtCursorPropertyManager::initializeProperty(QtProperty *property) {
#ifndef QT_NO_CURSOR
  d_ptr->m_values[property] = QCursor();
#endif
}

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

#if QT_VERSION >= 0x040400
QT_END_NAMESPACE
#endif

#include "moc_qtpropertymanager.cpp"
#include "qtpropertymanager.moc"