void IqtFit::fitContextMenu(const QPoint &) {
QtBrowserItem *item(NULL);
item = m_ffTree->currentItem();
if (!item)
return;
// is it a fit property ?
QtProperty *prop = item->property();
// is it already fixed?
bool fixed = prop->propertyManager() != m_dblManager;
if (fixed && prop->propertyManager() != m_stringManager)
return;
// Create the menu
QMenu *menu = new QMenu("IqtFit", m_ffTree);
QAction *action;
if (!fixed) {
action = new QAction("Fix", m_parentWidget);
connect(action, SIGNAL(triggered()), this, SLOT(fixItem()));
} else {
action = new QAction("Remove Fix", m_parentWidget);
connect(action, SIGNAL(triggered()), this, SLOT(unFixItem()));
}
menu->addAction(action);
// Show the menu
menu->popup(QCursor::pos());
}
QtProperty *CrossCommonPropertyGroup::extrackViewProperty(QtVariantPropertyManager *manager,
QHash<QString, QtVariantProperty *> &propertyTable)
{
QtProperty *parameters;
QtVariantProperty *item;
parameters = manager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString(QObject::tr("外观属性")));
item = manager->addProperty(QVariant::Color, QString(QObject::tr("背景颜色")));
item->setValue(QColor(0, 0, 0, 255));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/view/backgroud_color", item);
item = manager->addProperty(QVariant::Color, QString(QObject::tr("边框颜色")));
item->setValue(QColor(0, 0, 0, 255));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/view/border_color", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("边框宽度")));
item->setValue(1);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/view/border_line_width", item);
return parameters;
}
QtProperty *CrossCommonPropertyGroup::extrackCategoryAxisProperty(QtVariantPropertyManager *manager,
QHash<QString, QtVariantProperty *> &propertyTable)
{
QtProperty *parameters;
QtVariantProperty *item;
parameters = manager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString(QObject::tr("类型轴属性")));
item = manager->addProperty(QVariant::String, QString(QObject::tr("名称")));
item->setValue(QObject::tr("类型轴"));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/category_axis/name", item);
item = manager->addProperty(QVariant::Color, QString(QObject::tr("颜色")));
item->setValue(QColor(0, 0, 0, 255));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/category_axis/color", item);
item = manager->addProperty(QVariant::Bool, QString(QObject::tr("标签可见")));
item->setValue(true);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/category_axis/label_is_visible", item);
return parameters;
}
void QwtPlotPropertySetDialog::setAxisScaleDrawStyle(QwtPlot::Axis axis, const QVariant& value)
{
ScaleDraw sType = ScaleDraw( value.toInt());//强制转换，因为已经设置好枚举的值，所以这里可以进行强制转换
QwtScaleDraw *scaleDraw = m_plot->axisScaleDraw(axis);
QwtDateScaleDraw* dateScale = dynamic_cast<QwtDateScaleDraw*>(scaleDraw);
QtProperty * property = m_property_id.getProperty(axisPropertyID(axis,3));
if(NormalScale == sType)
{
if(property)
property->setEnabled(false);
if(dateScale)
{//说明当前是时间坐标轴
QwtScaleDraw* scale = nullptr;
scale = new QwtScaleDraw;
m_plot->setAxisScaleDraw(axis,scale);
}
}
else if(DateScale == sType)
{
ChartWave_qwt::AxisDateScaleType st(ChartWave_qwt::hh_mm_ss);
if(property)
{
property->setEnabled(true);
st = ChartWave_qwt::AxisDateScaleType( static_cast<QtVariantProperty*>(property)->value().toInt() );
}
if(!dateScale)
{//说明当前不是时间坐标轴
m_plot->setDateAxis(st,axis,QwtDate::Second);
}
}
}
void QtPropertyTreeView::drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyleOptionViewItemV3 opt = option;
QColor bgColor;
if (editorPrivate_)
{
QtProperty *property = editorPrivate_->indexToProperty(index);
if (property)
{
bgColor = property->getBackgroundColor();
}
}
if(bgColor.isValid())
{
painter->fillRect(option.rect, bgColor);
opt.palette.setColor(QPalette::AlternateBase, bgColor);
}
QTreeWidget::drawRow(painter, opt, index);
// QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
// painter->save();
// painter->setPen(QPen(color));
// painter->drawLine(opt.rect.x(), opt.rect.bottom(), opt.rect.right(), opt.rect.bottom());
// painter->restore();
}
QtProperty *ShapePropertyString::getQtProperty()
{
QtProperty *pProp = m_stringManager->addProperty( m_sName );
pProp->setToolTip( m_sDescription );
pProp->setWhatsThis( m_sDescription );
pProp->setEnabled( m_bEnabled );
return pProp;
}
QtProperty *ShapePropertyRCNames::getQtProperty()
{
QtProperty *pProp = m_keyMatrixNameManager->addProperty( m_sName );
pProp->setToolTip( m_sDescription );
pProp->setWhatsThis( m_sDescription );
pProp->setEnabled( m_bEnabled );
return pProp;
}
QtProperty *CrossCommonPropertyGroup::extrackValueAxisProperty(QtVariantPropertyManager *manager,
QHash<QString, QtVariantProperty *> &propertyTable)
{
QtProperty *parameters;
QtVariantProperty *item;
parameters = manager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString(QObject::tr("数值轴属性")));
item = manager->addProperty(QVariant::String, QString(QObject::tr("名称(单位)")));
item->setValue(QObject::tr("数值轴"));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/name", item);
item = manager->addProperty(QVariant::Color, QString(QObject::tr("颜色")));
item->setValue(QColor(0, 0, 0, 255));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/color", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("起始值")));
item->setValue(0);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/lower", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("结束值")));
item->setValue(100);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/upper", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("主刻度间隔")));
item->setValue(10);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/major_tick_size", item);
item = manager->addProperty(QVariant::Int, QString(QObject::tr("副刻度数量")));
item->setValue(5);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/minor_tick_count", item);
item = manager->addProperty(QVariant::Bool, QString(QObject::tr("主刻度可见")));
item->setValue(true);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/major_tick_is_visible", item);
item = manager->addProperty(QVariant::Bool, QString(QObject::tr("副刻度可见")));
item->setValue(true);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/minor_tick_is_visible", item);
item = manager->addProperty(QVariant::Bool, QString(QObject::tr("标签可见")));
item->setValue(true);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/value_axis/label_is_visible", item);
return parameters;
}
QtProperty *IqtFit::createExponential(const QString &name) {
QtProperty *expGroup = m_grpManager->addProperty(name);
m_properties[name + ".Intensity"] = m_dblManager->addProperty("Intensity");
m_dblManager->setDecimals(m_properties[name + ".Intensity"], NUM_DECIMALS);
m_properties[name + ".Tau"] = m_dblManager->addProperty("Tau");
m_dblManager->setDecimals(m_properties[name + ".Tau"], NUM_DECIMALS);
expGroup->addSubProperty(m_properties[name + ".Intensity"]);
expGroup->addSubProperty(m_properties[name + ".Tau"]);
return expGroup;
}
QtProperty *IqtFit::createStretchedExp(const QString &name) {
QtProperty *prop = m_grpManager->addProperty(name);
m_properties[name + ".Intensity"] = m_dblManager->addProperty("Intensity");
m_properties[name + ".Tau"] = m_dblManager->addProperty("Tau");
m_properties[name + ".Beta"] = m_dblManager->addProperty("Beta");
m_dblManager->setRange(m_properties[name + ".Beta"], 0, 1);
m_dblManager->setDecimals(m_properties[name + ".Intensity"], NUM_DECIMALS);
m_dblManager->setDecimals(m_properties[name + ".Tau"], NUM_DECIMALS);
m_dblManager->setDecimals(m_properties[name + ".Beta"], NUM_DECIMALS);
prop->addSubProperty(m_properties[name + ".Intensity"]);
prop->addSubProperty(m_properties[name + ".Tau"]);
prop->addSubProperty(m_properties[name + ".Beta"]);
return prop;
}
void IqtFit::fixItem() {
QtBrowserItem *item = m_ffTree->currentItem();
// Determine what the property is.
QtProperty *prop = item->property();
QtProperty *fixedProp = m_stringManager->addProperty(prop->propertyName());
QtProperty *fprlbl = m_stringManager->addProperty("Fixed");
fixedProp->addSubProperty(fprlbl);
m_stringManager->setValue(fixedProp, prop->valueText());
item->parent()->property()->addSubProperty(fixedProp);
m_fixedProps[fixedProp] = prop;
item->parent()->property()->removeSubProperty(prop);
}
int PropertyEditor::applyPropertiesFilter(const QList<QtBrowserItem *> &items)
{
int showCount = 0;
const bool matchAll = m_filterPattern.isEmpty();
QListIterator<QtBrowserItem *> itProperty(items);
while (itProperty.hasNext()) {
QtBrowserItem *propertyItem = itProperty.next();
QtProperty *property = propertyItem->property();
const QString propertyName = property->propertyName();
const bool showProperty = matchAll || propertyName.contains(m_filterPattern, Qt::CaseInsensitive);
setItemVisible(propertyItem, showProperty);
if (showProperty)
showCount++;
}
return showCount;
}
void ShapeKeyMatrix::PropertyChanged( QtBrowserItem *item, QList<PropertyValue *> & ) const
{
// if rows or columns change, update the key names editor
QtProperty *prop = item->property();
assert( prop != NULL );
if ( prop != NULL && prop->propertyName().compare( "Rows", Qt::CaseInsensitive ) == 0 )
{
int nRows = ShapeProperty::m_intManager->value( prop );
ShapeProperty::m_keyMatrixNameFactory->setRows( nRows );
}
else if ( prop != NULL && prop->propertyName().compare( "Columns", Qt::CaseInsensitive ) == 0 )
{
int nColumns = ShapeProperty::m_intManager->value( prop );
ShapeProperty::m_keyMatrixNameFactory->setColumns( nColumns );
}
}
void IqtFit::unFixItem() {
QtBrowserItem *item = m_ffTree->currentItem();
QtProperty *prop = item->property();
if (prop->subProperties().empty()) {
item = item->parent();
prop = item->property();
}
item->parent()->property()->addSubProperty(m_fixedProps[prop]);
item->parent()->property()->removeSubProperty(prop);
m_fixedProps.remove(prop);
QtProperty *proplbl = prop->subProperties()[0];
delete proplbl;
delete prop;
}
void InstrumentWidgetMaskTab::setProperties() {
clearProperties();
m_userEditing = false;
// bounding rect property
QtProperty *boundingRectGroup = m_groupManager->addProperty("Bounding Rect");
m_browser->addProperty(boundingRectGroup);
m_left = addDoubleProperty("left");
m_top = addDoubleProperty("top");
m_right = addDoubleProperty("right");
m_bottom = addDoubleProperty("bottom");
boundingRectGroup->addSubProperty(m_left);
boundingRectGroup->addSubProperty(m_top);
boundingRectGroup->addSubProperty(m_right);
boundingRectGroup->addSubProperty(m_bottom);
// point properties
QStringList pointProperties =
m_instrWidget->getSurface()->getCurrentPointNames();
foreach (QString name, pointProperties) {
QtProperty *point = m_groupManager->addProperty(name);
QtProperty *prop_x = addDoubleProperty("x");
QtProperty *prop_y = addDoubleProperty("y");
point->addSubProperty(prop_x);
point->addSubProperty(prop_y);
m_browser->addProperty(point);
m_pointComponentsMap[prop_x] = name;
m_pointComponentsMap[prop_y] = name;
m_pointPropertyMap[name] = point;
}
void PropertyEditor::storePropertiesExpansionState(const QList<QtBrowserItem *> &items)
{
const QChar bar = QLatin1Char('|');
QListIterator<QtBrowserItem *> itProperty(items);
while (itProperty.hasNext()) {
QtBrowserItem *propertyItem = itProperty.next();
if (!propertyItem->children().empty()) {
QtProperty *property = propertyItem->property();
const QString propertyName = property->propertyName();
const QMap<QtProperty *, QString>::const_iterator itGroup = m_propertyToGroup.constFind(property);
if (itGroup != m_propertyToGroup.constEnd()) {
QString key = itGroup.value();
key += bar;
key += propertyName;
m_expansionState[key] = isExpanded(propertyItem);
}
}
}
}
void PropertyEditor::fillView()
{
if (m_sorting) {
QMapIterator<QString, QtVariantProperty *> itProperty(m_nameToProperty);
while (itProperty.hasNext()) {
QtVariantProperty *property = itProperty.next().value();
m_currentBrowser->addProperty(property);
}
} else {
QListIterator<QtProperty *> itGroup(m_groups);
while (itGroup.hasNext()) {
QtProperty *group = itGroup.next();
QtBrowserItem *item = m_currentBrowser->addProperty(group);
if (m_currentBrowser == m_treeBrowser)
m_treeBrowser->setBackgroundColor(item, propertyColor(group));
group->setModified(m_currentBrowser == m_treeBrowser);
}
}
}
/** The move up button was clicked
*/
void QtSpacescapeMainWindow::onMoveLayerUp()
{
// get the selected layer
int layerId = getSelectedLayerId();
if(layerId > -1) {
if(ui->ogreWindow->moveLayerUp(layerId)) {
QList<QtBrowserItem *> bl = ui->layerProperties->topLevelItems();
unsigned int index = bl.size() - layerId - 1;
QtProperty *p = bl[index]->property();
// save expanded settings
bool expanded = ui->layerProperties->isExpanded(bl[index]);
// remove and re-insert at the new location
ui->layerProperties->removeProperty(p);
if(index == 1) {
ui->layerProperties->insertProperty(p, NULL);
}
else {
ui->layerProperties->insertProperty(p,bl[index - 2]->property());
}
// re-apply property tree visiblity settings
bl = ui->layerProperties->topLevelItems();
ui->layerProperties->setExpanded(bl[index - 1],expanded);
// un-expand the color items
QList<QtProperty *> sl = p->subProperties();
for(int i = 0; i < sl.size(); i++) {
if(((QtVariantProperty*)sl[i])->propertyType() == QVariant::Color) {
QList<QtBrowserItem *> bi = ui->layerProperties->items(sl[i]);
ui->layerProperties->setExpanded(bi.first(),false);
}
}
// re-select the item
ui->layerProperties->setFocus();
ui->layerProperties->setCurrentItem(bl[index - 1]);
}
}
}
QtProperty *CrossCommonPropertyGroup::extrackGridProperty(QtVariantPropertyManager *manager,
QHash<QString, QtVariantProperty *> &propertyTable)
{
QtProperty *parameters;
QtVariantProperty *item;
parameters = manager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString(QObject::tr("网格属性")));
item = manager->addProperty(QVariant::Color, QString(QObject::tr("颜色")));
item->setValue(QColor(0, 0, 0, 255));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/grid/color", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("粗细")));
item->setValue(1);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/grid/line_width", item);
return parameters;
}
void PropertyEditor::applyPropertiesExpansionState(const QList<QtBrowserItem *> &items)
{
const QChar bar = QLatin1Char('|');
QListIterator<QtBrowserItem *> itProperty(items);
while (itProperty.hasNext()) {
const QMap<QString, bool>::const_iterator excend = m_expansionState.constEnd();
QtBrowserItem *propertyItem = itProperty.next();
QtProperty *property = propertyItem->property();
const QString propertyName = property->propertyName();
const QMap<QtProperty *, QString>::const_iterator itGroup = m_propertyToGroup.constFind(property);
if (itGroup != m_propertyToGroup.constEnd()) {
QString key = itGroup.value();
key += bar;
key += propertyName;
const QMap<QString, bool>::const_iterator pit = m_expansionState.constFind(key);
if (pit != excend)
setExpanded(propertyItem, pit.value());
else
setExpanded(propertyItem, false);
}
}
}
/** Utility function for creating and inserting layer properties
@param layer Spacescape layer
@param insertAfter Property to insert after
@param minimize Minimize this layer
@return The created / inserted property
*/
QtProperty* QtSpacescapeMainWindow::insertLayerProperties(Ogre::SpacescapeLayer* layer, QtProperty *insertAfter, bool minimize)
{
// turn refreshing flag on so we don't process valueChanged events
mRefreshing = true;
// get layer params
Ogre::NameValuePairList params = layer->getParams();
// create the layer properties object
QtProperty *layerProperties = mPropertyManager->addProperty(
QtVariantPropertyManager::groupTypeId(),
QLatin1String(layer->getName().c_str())
);
// insert it into the property tree early so we can minize items inside
ui->layerProperties->insertProperty(layerProperties, insertAfter);
// minimize the layer - speeds things up!
if(minimize) {
ui->layerProperties->setExpanded(ui->layerProperties->topLevelItem(layerProperties), false);
}
// add the common layer params to the subproperties first
layerProperties->addSubProperty(createProperty( "name", layer->getName()));
layerProperties->addSubProperty(createProperty( "type", layer->getLayerTypeName()));
layerProperties->addSubProperty(createProperty( "visible", "true"));
layerProperties->addSubProperty(createProperty( "seed", params["seed"]));
// now add all the remaining layer params to the subproperties
Ogre::NameValuePairList::iterator pl;
for(pl = params.begin(); pl != params.end(); pl++) {
// skip common params that come first
if(pl->first == "name" || pl->first == "type" ||
pl->first == "visible" || pl->first == "seed") {
continue;
}
// create the sub property
QtVariantProperty* subProperty = createProperty(pl->first, pl->second);
if(!subProperty) {
continue;
}
// add this sub property parameter
layerProperties->addSubProperty(subProperty);
// special auto hide for color types
if(getPropertyType(pl->first) == QVariant::Color) {
QList<QtBrowserItem *> bi = ui->layerProperties->items(subProperty);
ui->layerProperties->setExpanded(bi.first(),false);
}
}
// done adding properties
mRefreshing = false;
return layerProperties;
}
void QtPropertyTreeView::mousePressEvent(QMouseEvent *event)
{
QTreeWidget::mousePressEvent(event);
QTreeWidgetItem *item = itemAt(event->pos());
if (item)
{
QtProperty *property = editorPrivate_->itemToProperty(item);
if ((item != editorPrivate_->getEditedItem()) &&
(event->button() == Qt::LeftButton) &&
(header()->logicalIndexAt(event->pos().x()) == 1) &&
isItemEditable(item->flags()))
{
editItem(item, 1);
}
else if (property && !property->hasValue() && editorPrivate_->markPropertiesWithoutValue() && !rootIsDecorated())
{
if (event->pos().x() + header()->offset() < 20)
item->setExpanded(!item->isExpanded());
}
}
}
QtProperty *ObjectController::getProperty(QString propertyName)
{
if (m_use_treeView)
{
QList<QtBrowserItem *> topLevelItems = d_ptr->m_browser->topLevelItems();
QList<QtBrowserItem *>::iterator i;
for (i = topLevelItems.begin(); i != topLevelItems.end(); ++i)
{
if ((*i))
{
QtProperty *rootprop = (*i)->property();
QString rootName = rootprop->propertyName();
//qDebug() << "Root PropertyName: " << rootName;
if (propertyName.compare(rootName) == 0)
{
return rootprop;
}
QList<QtBrowserItem *> children = (*i)->children();
QList<QtBrowserItem *>::iterator j;
for (j = children.begin(); j != children.end(); ++j)
{
if ((*j))
{
QtProperty *prop = (*j)->property();
QString propName = prop->propertyName();
//qDebug() << "Child PropertyName: " << propName;
if (propertyName.compare(propName) == 0)
{
return prop;
}
}
}
}
}
}
return nullptr;
}
/**
* Slot responding on a change of a masking shape.
*/
void InstrumentWindowMaskTab::shapeChanged()
{
if (!m_left) return; // check that everything is ok
m_userEditing = false; // this prevents resetting shape proeprties by doubleChanged(...)
RectF rect = m_instrWindow->getSurface()->getCurrentBoundingRect();
m_doubleManager->setValue(m_left,rect.x0());
m_doubleManager->setValue(m_top,rect.y1());
m_doubleManager->setValue(m_right,rect.x1());
m_doubleManager->setValue(m_bottom,rect.y0());
for(QMap<QtProperty *,QString>::iterator it = m_doublePropertyMap.begin(); it != m_doublePropertyMap.end(); ++it)
{
m_doubleManager->setValue(it.key(),m_instrWindow->getSurface()->getCurrentDouble(it.value()));
}
for(QMap<QString,QtProperty *>::iterator it = m_pointPropertyMap.begin(); it != m_pointPropertyMap.end(); ++it)
{
QtProperty* prop = it.value();
QList<QtProperty*> subs = prop->subProperties();
if (subs.size() != 2) continue;
QPointF p = m_instrWindow->getSurface()->getCurrentPoint(it.key());
m_doubleManager->setValue(subs[0],p.x());
m_doubleManager->setValue(subs[1],p.y());
}
m_userEditing = true;
}
void QtPropertyEditorView::drawRow(QPainter *painter,
const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyleOptionViewItemV3 opt = option;
bool hasValue = true;
if (m_editorPrivate)
{
QtProperty *property = m_editorPrivate->indexToProperty(index);
if (property)
hasValue = property->hasValue();
}
if (!hasValue && m_editorPrivate->markPropertiesWithoutValue())
{
const QColor c = option.palette.color(QPalette::Dark);
painter->fillRect(option.rect, c);
opt.palette.setColor(QPalette::AlternateBase, c);
}
else
{
const QColor c = m_editorPrivate->calculatedBackgroundColor(
m_editorPrivate->indexToBrowserItem(index));
if (c.isValid())
{
painter->fillRect(option.rect, c);
opt.palette.setColor(QPalette::AlternateBase, c.lighter(112));
}
}
QTreeWidget::drawRow(painter, opt, index);
QColor color = static_cast<QRgb>(
QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
painter->save();
painter->setPen(QPen(color));
painter->drawLine(opt.rect.x(), opt.rect.bottom(), opt.rect.right(),
opt.rect.bottom());
painter->restore();
}
QtProperty *CrossCommonPropertyGroup::extrackBaseProperty(QtVariantPropertyManager *manager,
QHash<QString, QtVariantProperty *> &propertyTable)
{
QtProperty *parameters;
QtVariantProperty *item;
parameters = manager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString(QObject::tr("基本属性")));
#ifdef QT_DEBUG
item = manager->addProperty(QVariant::Int, QString(QObject::tr("id(发布版本无此项)")));
item->setValue("0");
item->setEnabled(false);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/id", item);
#endif
item = manager->addProperty(QVariant::String, QString(QObject::tr("图名")));
item->setValue(QObject::tr("交会图"));
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/title", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("宽度")));
item->setValue(400);
item->setAttribute(QLatin1String("minimum"), 0);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/width", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("高度")));
item->setValue(300);
item->setAttribute(QLatin1String("minimum"), 0);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/height", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("x")));
item->setValue(0);
item->setAttribute(QLatin1String("minimum"), 0);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/x", item);
item = manager->addProperty(QVariant::Double, QString(QObject::tr("y")));
item->setValue(0);
item->setAttribute(QLatin1String("minimum"), 0);
parameters->addSubProperty(item);
propertyTable.insert("/map_key/base/y", item);
return parameters;
}
void LineEditPropertyFactory::EditorDestroyed(QObject *object)
{
QMap<QLineEdit*, QtProperty*>::ConstIterator iter = editorToProperty_.constBegin();
while (iter != editorToProperty_.constEnd())
{
if (iter.key() == object)
{
QLineEdit *editor = iter.key();
QtProperty *property = iter.value();
QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager*>(property->propertyManager());
if(stringManager)
stringManager->setValue(property, iter.key()->text());
editorToProperty_.remove(editor);
propertyToEditor_.remove(property);
int size = editorToProperty_.size();
size = propertyToEditor_.size();
break;
}
iter++;
}
}
void PropertyEditor::setObject(QObject *object)
{
QDesignerFormWindowInterface *oldFormWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
// In the first setObject() call following the addition of a dynamic property, focus and edit it.
const bool editNewDynamicProperty = object != 0 && m_object == object && !m_recentlyAddedDynamicProperty.isEmpty();
m_object = object;
m_propertyManager->setObject(object);
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
FormWindowBase *fwb = qobject_cast<FormWindowBase *>(formWindow);
m_treeFactory->setFormWindowBase(fwb);
m_groupFactory->setFormWindowBase(fwb);
storeExpansionState();
UpdateBlocker ub(this);
updateToolBarLabel();
QMap<QString, QtVariantProperty *> toRemove = m_nameToProperty;
const QDesignerDynamicPropertySheetExtension *dynamicSheet =
qt_extension<QDesignerDynamicPropertySheetExtension*>(m_core->extensionManager(), m_object);
const QDesignerPropertySheet *sheet = qobject_cast<QDesignerPropertySheet*>(m_core->extensionManager()->extension(m_object, Q_TYPEID(QDesignerPropertySheetExtension)));
// Optimizization: Instead of rebuilding the complete list every time, compile a list of properties to remove,
// remove them, traverse the sheet, in case property exists just set a value, otherwise - create it.
QExtensionManager *m = m_core->extensionManager();
m_propertySheet = qobject_cast<QDesignerPropertySheetExtension*>(m->extension(object, Q_TYPEID(QDesignerPropertySheetExtension)));
if (m_propertySheet) {
const int propertyCount = m_propertySheet->count();
for (int i = 0; i < propertyCount; ++i) {
if (!m_propertySheet->isVisible(i))
continue;
const QString propertyName = m_propertySheet->propertyName(i);
if (m_propertySheet->indexOf(propertyName) != i)
continue;
const QString groupName = m_propertySheet->propertyGroup(i);
const QMap<QString, QtVariantProperty *>::const_iterator rit = toRemove.constFind(propertyName);
if (rit != toRemove.constEnd()) {
QtVariantProperty *property = rit.value();
if (m_propertyToGroup.value(property) == groupName && toBrowserType(m_propertySheet->property(i), propertyName) == property->propertyType())
toRemove.remove(propertyName);
}
}
}
QMapIterator<QString, QtVariantProperty *> itRemove(toRemove);
while (itRemove.hasNext()) {
itRemove.next();
QtVariantProperty *property = itRemove.value();
m_nameToProperty.remove(itRemove.key());
m_propertyToGroup.remove(property);
delete property;
}
if (oldFormWindow != formWindow)
reloadResourceProperties();
bool isMainContainer = false;
if (QWidget *widget = qobject_cast<QWidget*>(object)) {
if (QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(widget)) {
isMainContainer = (fw->mainContainer() == widget);
}
}
m_groups.clear();
if (m_propertySheet) {
QtProperty *lastProperty = 0;
QtProperty *lastGroup = 0;
const int propertyCount = m_propertySheet->count();
for (int i = 0; i < propertyCount; ++i) {
if (!m_propertySheet->isVisible(i))
continue;
const QString propertyName = m_propertySheet->propertyName(i);
if (m_propertySheet->indexOf(propertyName) != i)
continue;
const QVariant value = m_propertySheet->property(i);
const int type = toBrowserType(value, propertyName);
QtVariantProperty *property = m_nameToProperty.value(propertyName, 0);
bool newProperty = property == 0;
if (newProperty) {
property = m_propertyManager->addProperty(type, propertyName);
if (property) {
newProperty = true;
if (type == DesignerPropertyManager::enumTypeId()) {
const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(value);
QStringList names;
QStringListIterator it(e.metaEnum.keys());
while (it.hasNext())
names.append(it.next());
m_updatingBrowser = true;
property->setAttribute(m_strings.m_enumNamesAttribute, names);
m_updatingBrowser = false;
} else if (type == DesignerPropertyManager::designerFlagTypeId()) {
const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(value);
QList<QPair<QString, uint> > flags;
QStringListIterator it(f.metaFlags.keys());
while (it.hasNext()) {
const QString name = it.next();
const uint val = f.metaFlags.keyToValue(name);
flags.append(qMakePair(name, val));
}
m_updatingBrowser = true;
QVariant v;
qVariantSetValue(v, flags);
property->setAttribute(m_strings.m_flagsAttribute, v);
m_updatingBrowser = false;
}
}
}
if (property != 0) {
const bool dynamicProperty = (dynamicSheet && dynamicSheet->isDynamicProperty(i))
|| (sheet && sheet->isDefaultDynamicProperty(i));
switch (type) {
case QVariant::Palette:
setupPaletteProperty(property);
break;
case QVariant::KeySequence:
//addCommentProperty(property, propertyName);
break;
default:
break;
}
if (type == QVariant::String || type == qMetaTypeId<PropertySheetStringValue>())
setupStringProperty(property, isMainContainer);
property->setAttribute(m_strings.m_resettableAttribute, m_propertySheet->hasReset(i));
const QString groupName = m_propertySheet->propertyGroup(i);
QtVariantProperty *groupProperty = 0;
if (newProperty) {
QMap<QString, QtVariantProperty*>::const_iterator itPrev = m_nameToProperty.insert(propertyName, property);
m_propertyToGroup[property] = groupName;
if (m_sorting) {
QtProperty *previous = 0;
if (itPrev != m_nameToProperty.constBegin())
previous = (--itPrev).value();
m_currentBrowser->insertProperty(property, previous);
}
}
const QMap<QString, QtVariantProperty*>::const_iterator gnit = m_nameToGroup.constFind(groupName);
if (gnit != m_nameToGroup.constEnd()) {
groupProperty = gnit.value();
} else {
groupProperty = m_propertyManager->addProperty(QtVariantPropertyManager::groupTypeId(), groupName);
QtBrowserItem *item = 0;
if (!m_sorting)
item = m_currentBrowser->insertProperty(groupProperty, lastGroup);
m_nameToGroup[groupName] = groupProperty;
m_groups.append(groupProperty);
if (dynamicProperty)
m_dynamicGroup = groupProperty;
if (m_currentBrowser == m_treeBrowser && item) {
m_treeBrowser->setBackgroundColor(item, propertyColor(groupProperty));
groupProperty->setModified(true);
}
}
/* Group changed or new group. Append to last subproperty of
* that group. Note that there are cases in which a derived
* property sheet appends fake properties for the class
* which will appear after the layout group properties
* (QWizardPage). To make them appear at the end of the
* actual class group, goto last element. */
if (lastGroup != groupProperty) {
lastGroup = groupProperty;
lastProperty = 0; // Append at end
const QList<QtProperty*> subProperties = lastGroup->subProperties();
if (!subProperties.empty())
lastProperty = subProperties.back();
lastGroup = groupProperty;
}
if (!m_groups.contains(groupProperty))
m_groups.append(groupProperty);
if (newProperty)
groupProperty->insertSubProperty(property, lastProperty);
lastProperty = property;
updateBrowserValue(property, value);
property->setModified(m_propertySheet->isChanged(i));
if (propertyName == QLatin1String("geometry") && type == QVariant::Rect) {
QList<QtProperty *> subProperties = property->subProperties();
foreach (QtProperty *subProperty, subProperties) {
const QString subPropertyName = subProperty->propertyName();
if (subPropertyName == QLatin1String("X") || subPropertyName == QLatin1String("Y"))
subProperty->setEnabled(!isMainContainer);
}
}
} else {
qWarning("%s", qPrintable(msgUnsupportedType(propertyName, type)));
}
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QtVariantPropertyManager *variantManager = new QtVariantPropertyManager();
int i = 0;
QtProperty *topItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
QString::number(i++) + QLatin1String(" Group Property"));
QtVariantProperty *item = variantManager->addProperty(QVariant::Bool, QString::number(i++) + QLatin1String(" Bool Property"));
item->setValue(true);
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Int, QString::number(i++) + QLatin1String(" Int Property"));
item->setValue(20);
item->setAttribute(QLatin1String("minimum"), 0);
item->setAttribute(QLatin1String("maximum"), 100);
item->setAttribute(QLatin1String("singleStep"), 10);
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Double, QString::number(i++) + QLatin1String(" Double Property"));
item->setValue(1.2345);
item->setAttribute(QLatin1String("singleStep"), 0.1);
item->setAttribute(QLatin1String("decimals"), 3);
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::String, QString::number(i++) + QLatin1String(" String Property"));
item->setValue("Value");
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Date, QString::number(i++) + QLatin1String(" Date Property"));
item->setValue(QDate::currentDate().addDays(2));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Time, QString::number(i++) + QLatin1String(" Time Property"));
item->setValue(QTime::currentTime());
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::DateTime, QString::number(i++) + QLatin1String(" DateTime Property"));
item->setValue(QDateTime::currentDateTime());
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::KeySequence, QString::number(i++) + QLatin1String(" KeySequence Property"));
item->setValue(QKeySequence(Qt::ControlModifier | Qt::Key_Q));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Char, QString::number(i++) + QLatin1String(" Char Property"));
item->setValue(QChar(386));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Locale, QString::number(i++) + QLatin1String(" Locale Property"));
item->setValue(QLocale(QLocale::Polish, QLocale::Poland));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Point, QString::number(i++) + QLatin1String(" Point Property"));
item->setValue(QPoint(10, 10));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::PointF, QString::number(i++) + QLatin1String(" PointF Property"));
item->setValue(QPointF(1.2345, -1.23451));
item->setAttribute(QLatin1String("decimals"), 3);
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Size, QString::number(i++) + QLatin1String(" Size Property"));
item->setValue(QSize(20, 20));
item->setAttribute(QLatin1String("minimum"), QSize(10, 10));
item->setAttribute(QLatin1String("maximum"), QSize(30, 30));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::SizeF, QString::number(i++) + QLatin1String(" SizeF Property"));
item->setValue(QSizeF(1.2345, 1.2345));
item->setAttribute(QLatin1String("decimals"), 3);
item->setAttribute(QLatin1String("minimum"), QSizeF(0.12, 0.34));
item->setAttribute(QLatin1String("maximum"), QSizeF(20.56, 20.78));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Rect, QString::number(i++) + QLatin1String(" Rect Property"));
item->setValue(QRect(10, 10, 20, 20));
topItem->addSubProperty(item);
item->setAttribute(QLatin1String("constraint"), QRect(0, 0, 50, 50));
item = variantManager->addProperty(QVariant::RectF, QString::number(i++) + QLatin1String(" RectF Property"));
item->setValue(QRectF(1.2345, 1.2345, 1.2345, 1.2345));
topItem->addSubProperty(item);
item->setAttribute(QLatin1String("constraint"), QRectF(0, 0, 50, 50));
item->setAttribute(QLatin1String("decimals"), 3);
item = variantManager->addProperty(QtVariantPropertyManager::enumTypeId(),
QString::number(i++) + QLatin1String(" Enum Property"));
QStringList enumNames;
enumNames << "Enum0" << "Enum1" << "Enum2";
item->setAttribute(QLatin1String("enumNames"), enumNames);
item->setValue(1);
topItem->addSubProperty(item);
item = variantManager->addProperty(QtVariantPropertyManager::flagTypeId(),
QString::number(i++) + QLatin1String(" Flag Property"));
QStringList flagNames;
flagNames << "Flag0" << "Flag1" << "Flag2";
item->setAttribute(QLatin1String("flagNames"), flagNames);
item->setValue(5);
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::SizePolicy, QString::number(i++) + QLatin1String(" SizePolicy Property"));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Font, QString::number(i++) + QLatin1String(" Font Property"));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Cursor, QString::number(i++) + QLatin1String(" Cursor Property"));
topItem->addSubProperty(item);
item = variantManager->addProperty(QVariant::Color, QString::number(i++) + QLatin1String(" Color Property"));
topItem->addSubProperty(item);
QtVariantEditorFactory *variantFactory = new QtVariantEditorFactory();
QtTreePropertyBrowser *variantEditor = new QtTreePropertyBrowser();
variantEditor->setFactoryForManager(variantManager, variantFactory);
variantEditor->addProperty(topItem);
variantEditor->setPropertiesWithoutValueMarked(true);
variantEditor->setRootIsDecorated(false);
variantEditor->show();
int ret = app.exec();
delete variantManager;
delete variantFactory;
delete variantEditor;
return ret;
}
void PropertyEditorView::setRootIndex(const QModelIndex &index)
{
mPropertyEditor->clear();
mPropertyEditor->unsetFactoryForManager(mButtonManager);
mPropertyEditor->unsetFactoryForManager(mVariantManager);
delete mVariantManager;
delete mVariantFactory;
delete mButtonManager;
delete mButtonFactory;
mVariantManager = new QtVariantPropertyManager();
mVariantFactory = new QtVariantEditorFactory();
mButtonManager = new PushButtonPropertyManager();
mButtonFactory = new PushButtonFactory();
mPropertyEditor->setFactoryForManager(mButtonManager, mButtonFactory);
mPropertyEditor->setFactoryForManager(mVariantManager, mVariantFactory);
for (int i = 0, rows = mModel->rowCount(index); i < rows; ++i) {
const QModelIndex &valueCell = mModel->index(i, 1);
QString name = mModel->data(mModel->index(i, 0)).toString();
const QVariant &value = mModel->data(valueCell);
int type = QVariant::String;
QString typeName = mModel->typeName(valueCell).toLower();
QList<QPair<QString, QString>> const values = mModel->enumValues(valueCell);
bool isButton = false;
if (typeName == "int") {
type = QVariant::Int;
} else if (typeName == "bool") {
type = QVariant::Bool;
} else if (typeName == "string") {
type = QVariant::String;
} else if (typeName == "code" || typeName == "directorypath" || typeName == "filepath") {
isButton = true;
} else if (!values.isEmpty()) {
type = QtVariantPropertyManager::enumTypeId();
}
/// @todo: Not property name should be hard-coded, new type must be introduced (like 'sdf' or 'qml')!
if ((name == "shape" && typeName == "string") || mModel->isReference(valueCell, name)) { // hack
isButton = true;
}
QtProperty *item = nullptr;
if (isButton) {
item = mButtonManager->addProperty(name);
} else {
QtVariantProperty *vItem = mVariantManager->addProperty(type, name);
vItem->setValue(value);
vItem->setToolTip(value.toString());
if (!values.isEmpty()) {
QStringList friendlyNames;
for (QPair<QString, QString> const &pair : values) {
friendlyNames << pair.second;
}
vItem->setAttribute("enumNames", friendlyNames);
vItem->setAttribute("enumEditable", mModel->enumEditable(valueCell));
const int idx = enumPropertyIndexOf(valueCell, value.toString());
if (mModel->enumEditable(valueCell)) {
vItem->setValue(idx < 0 ? value.toString() : values[idx].second);
} else {
vItem->setValue(idx);
}
}
item = vItem;
}
const QString description = propertyDescription(i);
if (!description.isEmpty()) {
item->setToolTip(description);
}
mPropertyEditor->addProperty(item);
}
connect(mButtonManager, SIGNAL(buttonClicked(QtProperty*))
, this, SLOT(buttonClicked(QtProperty*)), Qt::UniqueConnection);
connect(mVariantManager, SIGNAL(valueChanged(QtProperty*, QVariant))
, this, SLOT(editorValueChanged(QtProperty *, QVariant)), Qt::UniqueConnection);
mPropertyEditor->setPropertiesWithoutValueMarked(true);
mPropertyEditor->setRootIsDecorated(false);
}
