static inline void applyProperties(ModelNode &node, const QHash<PropertyName, QVariant> &propertyHash)
{
QHash<PropertyName, QVariant> auxiliaryData = node.auxiliaryData();
foreach (const PropertyName &propertyName, auxiliaryData.keys()) {
if (node.hasAuxiliaryData(propertyName))
node.setAuxiliaryData(propertyName, QVariant());
}
QHashIterator<PropertyName, QVariant> propertyIterator(propertyHash);
while (propertyIterator.hasNext()) {
propertyIterator.next();
const PropertyName propertyName = propertyIterator.key();
if (propertyName == "width" || propertyName == "height") {
node.setAuxiliaryData(propertyIterator.key(), propertyIterator.value());
} else if (node.property(propertyIterator.key()).isDynamic() &&
node.property(propertyIterator.key()).dynamicTypeName() == "alias" &&
node.property(propertyIterator.key()).isBindingProperty()) {
AbstractProperty targetProperty = node.bindingProperty(propertyIterator.key()).resolveToProperty();
if (targetProperty.isValid())
targetProperty.parentModelNode().setAuxiliaryData(targetProperty.name() + "@NodeInstance", propertyIterator.value());
} else {
node.setAuxiliaryData(propertyIterator.key() + "@NodeInstance", propertyIterator.value());
}
}
}
const AbstractProperty * PropertyGroup::findProperty(const std::vector<std::string> & path) const
{
// [TODO] Use iterative approach rather than recursion
// Check if path is valid
if (path.size() == 0) {
return nullptr;
}
// Check if first element of the path exists in this group
if (!propertyExists(path.front())) {
return nullptr;
}
// Get the respective property
AbstractProperty * property = m_propertiesMap.at(path.front());
// If there are no more sub-paths, return the found property
if (path.size() == 1) {
return property;
}
// Otherwise, it is an element in the middle of the path, so ensure it is a group
if (!property->isGroup()) {
return nullptr;
}
// Call recursively on subgroup
return property->asGroup()->findProperty({ path.begin() + 1, path.end() });
}
AbstractProperty::AbstractProperty(const AbstractProperty &property, AbstractView *view)
: m_propertyName(property.name()),
m_internalNode(property.internalNode()),
m_model(property.model()),
m_view(view)
{
}
QWidget * PropertyDelegate::createEditor(QWidget * parent,
const QStyleOptionViewItem & option, const QModelIndex & index) const
{
AbstractProperty * property = retrieveProperty(index);
if (property->isCollection())
return QStyledItemDelegate::createEditor(parent, option, index);
return m_editorFactory->createEditor(*property, parent);
}
void VariantEditor::setString(const QString & text)
{
AbstractProperty * prop = dynamic_cast<AbstractProperty *>(m_property);
if (prop == nullptr)
{
return;
}
prop->fromString(text.toStdString());
}
Icon*
CtlMediaObject::getIcon()
{
// icon property is a lower resolution thumb nail of the original picture (but should be displayable on a handheld device).
// TODO: adapt icon to new media object implementataion
AbstractProperty* pProperty = getProperty(AvProperty::ICON);
if (pProperty) {
return new Icon(0, 0, 0, Mime::IMAGE_JPEG, pProperty->getValue());
}
return 0;
}
Variant PropertyGroup::toVariant() const
{
// Create variant map from all properties in the group
Variant map = Variant::map();
for (auto it : m_propertiesMap) {
// Get name and property
std::string name = it.first;
AbstractProperty * prop = it.second;
// Add to variant map
(*map.asMap())[name] = prop->toVariant();
}
// Return variant representation
return map;
}
void PropertyBrowser::expandAllGroups()
{
QAbstractItemModel * model = this->model();
QModelIndexList indexes = model->match(model->index(0,0), Qt::DisplayRole, "*", -1, Qt::MatchWildcard|Qt::MatchRecursive);
for (QModelIndex index : indexes)
{
if (!index.isValid())
continue;
AbstractProperty * property = retrieveProperty(index);
if (property->isGroup() && model->hasChildren(index))
expand(index);
}
}
void PropertyDelegate::paint(QPainter * painter,
const QStyleOptionViewItem & option,
const QModelIndex & index) const
{
QStyledItemDelegate::paint(painter, option, index);
AbstractProperty * property = retrieveProperty(index);
if (property->isCollection())
return;
QStyleOptionViewItem opt = option;
initStyleOption(&opt, index);
m_propertyPainter->drawValue(painter, opt, *property);
}
void AbstractCollection::acceptRecursive(AbstractVisitor * visitor)
{
// Visit all values of the collection
for (size_t i=0; i<count(); i++) {
// Get property
AbstractProperty * prop = at(i);
// Visit property
prop->accept(visitor);
// If it is a collection, visit collection recursively
AbstractCollection * collection = dynamic_cast<AbstractCollection *>(prop);
if (collection) {
collection->acceptRecursive(visitor);
}
}
}
void PropertyBrowser::onRowsInserted(const QModelIndex & parentIndex, int first, int last)
{
QAbstractItemModel * model = this->model();
for (int i = first; i <= last; ++i)
{
QModelIndex index = model->index(i, 0, parentIndex);
if (!index.isValid())
continue;
AbstractProperty * property = retrieveProperty(index);
if (property->isGroup() && model->hasChildren(index))
expand(index);
}
}
void PropertyObj::assign(const AbstractProperty& that) {
try {
*this = dynamic_cast<const PropertyObj&>(that);
} catch(const std::bad_cast&) {
OPENSIM_THROW(InvalidArgument,
"Unsupported type. Expected: " + this->getTypeName() +
" | Received: " + that.getTypeName());
}
}
QmlDesigner::QmlRefactoring::PropertyType ModelToTextMerger::propertyType(const AbstractProperty &property, const QString &textValue)
{
if (property.isBindingProperty()) {
QString val = textValue.trimmed();
if (val.isEmpty())
return QmlDesigner::QmlRefactoring::ObjectBinding;
const QChar lastChar = val.at(val.size() - 1);
if (lastChar == '}' || lastChar == ';')
return QmlDesigner::QmlRefactoring::ObjectBinding;
else
return QmlDesigner::QmlRefactoring::ScriptBinding;
} else if (property.isNodeListProperty())
return QmlDesigner::QmlRefactoring::ArrayBinding;
else if (property.isNodeProperty())
return QmlDesigner::QmlRefactoring::ObjectBinding;
else if (property.isVariantProperty())
return QmlDesigner::QmlRefactoring::ScriptBinding;
Q_ASSERT(!"cannot convert property type");
return (QmlDesigner::QmlRefactoring::PropertyType) -1;
}
bool detectVerticalCycle(const ModelNode &node, QList<ModelNode> knownNodeList)
{
if (!node.isValid())
return false;
if (knownNodeList.contains(node))
return true;
knownNodeList.append(node);
static QStringList validAnchorLines(QStringList() << "top" << "bottom" << "verticalCenter" << "baseline");
static QStringList anchorNames(QStringList() << "anchors.top" << "anchors.bottom" << "anchors.verticalCenter" << "anchors.baseline");
foreach (const QString &anchorName, anchorNames) {
if (node.hasBindingProperty(anchorName)) {
AbstractProperty targetProperty = node.bindingProperty(anchorName).resolveToProperty();
if (targetProperty.isValid()) {
if (!validAnchorLines.contains(targetProperty.name()))
return true;
if (detectVerticalCycle(targetProperty.parentModelNode(), knownNodeList))
return true;
}
}
}
static QStringList anchorShortcutNames(QStringList() << "anchors.fill" << "anchors.centerIn");
foreach (const QString &anchorName, anchorShortcutNames) {
if (node.hasBindingProperty(anchorName)) {
ModelNode targetNode = node.bindingProperty(anchorName).resolveToModelNode();
if (targetNode.isValid() && detectVerticalCycle(targetNode, knownNodeList))
return true;
}
}
return false;
}
PropertyGroup * PropertyGroup::ensureGroup(const std::vector<std::string> & path)
{
// [TODO] Use iterative approach rather than recursion
// Check if path is valid
if (path.size() == 0) {
return nullptr;
}
// Check if group exists
PropertyGroup * group = nullptr;
if (propertyExists(path.front()))
{
// Get property
AbstractProperty * property = m_propertiesMap.at(path.front());
// Abort if this is not a group
if (!property->isGroup()) {
return nullptr;
}
// Get as group
group = property->asGroup();
}
else
{
// Add new group
group = addGroup(path.front());
}
// If there are no more sub-paths, return the group
if (path.size() == 1) {
return group;
}
// Otherwise, call recursively on subgroup
return group->ensureGroup(std::vector<std::string>(path.begin() + 1, path.end()));
}
bool PropertyGroup::fromVariant(const Variant & value)
{
// Check if variant is a map
if (!value.isMap()) {
return false;
}
// Get all values from variant map
for (auto it : *value.asMap()) {
// Get name and value
std::string name = it.first;
const Variant & var = it.second;
// If this names an existing property, set its value
AbstractProperty * prop = this->property(name);
if (prop) {
prop->fromVariant(var);
}
}
// Done
return true;
}
QWidget * VariantEditor::createLineEdit()
{
auto lineEdit = new QLineEdit{this};
AbstractProperty * prop = dynamic_cast<AbstractProperty *>(m_property);
if (prop == nullptr)
{
return nullptr;
}
lineEdit->setText(QString::fromStdString(prop->toString()));
connect(lineEdit, &QLineEdit::textEdited, this, &VariantEditor::setString);
m_propertyChangedConnection = prop->changed.connect(
[this, lineEdit, prop]()
{
lineEdit->setText(QString::fromStdString(prop->toString()));
});
return lineEdit;
}
bool detectHorizontalCycle(const ModelNode &node, QList<ModelNode> knownNodeList)
{
if (knownNodeList.contains(node))
return true;
knownNodeList.append(node);
static PropertyNameList validAnchorLines(PropertyNameList() << "right" << "left" << "horizontalCenter");
static PropertyNameList anchorNames(PropertyNameList() << "anchors.right" << "anchors.left" << "anchors.horizontalCenter");
foreach (const PropertyName &anchorName, anchorNames) {
if (node.hasBindingProperty(anchorName)) {
AbstractProperty targetProperty = node.bindingProperty(anchorName).resolveToProperty();
if (targetProperty.isValid()) {
if (!validAnchorLines.contains(targetProperty.name()))
return true;
if (detectHorizontalCycle(targetProperty.parentModelNode(), knownNodeList))
return true;
}
}
}
static PropertyNameList anchorShortcutNames(PropertyNameList() << "anchors.fill" << "anchors.centerIn");
foreach (const PropertyName &anchorName, anchorShortcutNames) {
if (node.hasBindingProperty(anchorName)) {
ModelNode targetNode = node.bindingProperty(anchorName).resolveToModelNode();
if (targetNode.isValid() && detectHorizontalCycle(targetNode, knownNodeList))
return true;
}
}
return false;
}
QVariant PropertyModel::data(const QModelIndex & index, int role) const
{
if (!index.isValid())
return QVariant();
AbstractProperty * property = retrieveItem(index)->property();
if (role == Qt::DisplayRole && index.column() == 0)
{
std::string title;
if (property->hasOption("title"))
title = property->option("title").value<std::string>();
else
title = property->name();
return QVariant(QString::fromStdString(title));
}
if (role == Qt::ToolTipRole && property->hasOption("tooltip"))
return QVariant(QString::fromStdString(property->option("tooltip").value<std::string>()));
return QVariant();
}
QString QmlTextGenerator::toQml(const AbstractProperty &property, int indentDepth) const
{
if (property.isBindingProperty()) {
return property.toBindingProperty().expression();
} else if (property.isSignalHandlerProperty()) {
return property.toSignalHandlerProperty().source();
} else if (property.isNodeProperty()) {
return toQml(property.toNodeProperty().modelNode(), indentDepth);
} else if (property.isNodeListProperty()) {
const QList<ModelNode> nodes = property.toNodeListProperty().toModelNodeList();
if (property.isDefaultProperty()) {
QString result;
for (int i = 0; i < nodes.length(); ++i) {
if (i > 0)
result += QLatin1String("\n\n");
result += QString(indentDepth, QLatin1Char(' '));
result += toQml(nodes.at(i), indentDepth);
}
return result;
} else {
QString result = QLatin1String("[");
const int arrayContentDepth = indentDepth + 4;
const QString arrayContentIndentation(arrayContentDepth, QLatin1Char(' '));
for (int i = 0; i < nodes.length(); ++i) {
if (i > 0)
result += QLatin1Char(',');
result += QLatin1Char('\n');
result += arrayContentIndentation;
result += toQml(nodes.at(i), arrayContentDepth);
}
return result + QLatin1Char(']');
}
} else if (property.isVariantProperty()) {
const VariantProperty variantProperty = property.toVariantProperty();
const QVariant value = variantProperty.value();
const QString stringValue = value.toString();
if (property.name() == "id")
return stringValue;
if (variantProperty.parentModelNode().metaInfo().isValid()
&& variantProperty.parentModelNode().metaInfo().propertyIsEnumType(variantProperty.name())) {
return variantProperty.parentModelNode().metaInfo().propertyEnumScope(variantProperty.name())
+ QLatin1String(".") + stringValue;
//Enums do not work with alias properties. This is a workaround.
} else if (variantProperty.parentModelNode().metaInfo().isValid()
//Enums are not strings
&& variantProperty.parentModelNode().metaInfo().propertyTypeName(variantProperty.name())
!= ("string")
&& variantProperty.parentModelNode().metaInfo().propertyTypeName(variantProperty.name())
!= ("QString")
//We check if the value of the property is one of the known Qt Quick enums.
&& NodeMetaInfo::qtQuickEnumsWithoutScope().contains(stringValue)
) {
return NodeMetaInfo::qtQuickEnumScopeForEnumString(stringValue) + QLatin1String(".") + stringValue;
} else {
switch (value.type()) {
case QVariant::Bool:
if (value.value<bool>())
return QLatin1String("true");
else
return QLatin1String("false");
case QVariant::Color:
return QString(QLatin1String("\"%1\"")).arg(properColorName(value.value<QColor>()));
case QVariant::Double:
return doubleToString(value.toDouble());
case QVariant::Int:
case QVariant::LongLong:
case QVariant::UInt:
case QVariant::ULongLong:
return stringValue;
default:
return QString(QLatin1String("\"%1\"")).arg(escape(stringValue));
}
}
} else {
Q_ASSERT("Unknown property type");
return QString();
}
}
QDebug operator<<(QDebug debug, const AbstractProperty &property)
{
return debug.nospace() << "AbstractProperty(" << (property.isValid() ? property.name() : PropertyName("invalid")) << ')';
}
QString QmlTextGenerator::toQml(const AbstractProperty &property, int indentDepth) const
{
if (property.isBindingProperty()) {
return property.toBindingProperty().expression();
} else if (property.isNodeProperty()) {
return toQml(property.toNodeProperty().modelNode(), indentDepth);
} else if (property.isNodeListProperty()) {
const QList<ModelNode> nodes = property.toNodeListProperty().toModelNodeList();
if (property.isDefaultProperty()) {
QString result;
for (int i = 0; i < nodes.length(); ++i) {
if (i > 0)
result += QLatin1String("\n\n");
result += QString(indentDepth, QLatin1Char(' '));
result += toQml(nodes.at(i), indentDepth);
}
return result;
} else {
QString result = QLatin1String("[");
const int arrayContentDepth = indentDepth + 4;
const QString arrayContentIndentation(arrayContentDepth, QLatin1Char(' '));
for (int i = 0; i < nodes.length(); ++i) {
if (i > 0)
result += QLatin1Char(',');
result += QLatin1Char('\n');
result += arrayContentIndentation;
result += toQml(nodes.at(i), arrayContentDepth);
}
return result + QLatin1Char(']');
}
} else if (property.isVariantProperty()) {
const VariantProperty variantProperty = property.toVariantProperty();
const QVariant value = variantProperty.value();
const QString stringValue = value.toString();
if (property.name() == QLatin1String("id"))
return stringValue;
if (false) {
}
if (variantProperty.parentModelNode().metaInfo().isValid() &&
variantProperty.parentModelNode().metaInfo().propertyIsEnumType(variantProperty.name())) {
return variantProperty.parentModelNode().metaInfo().propertyEnumScope(variantProperty.name()) + '.' + stringValue;
} else {
switch (value.type()) {
case QVariant::Bool:
if (value.value<bool>())
return QLatin1String("true");
else
return QLatin1String("false");
case QVariant::Color:
return QString(QLatin1String("\"%1\"")).arg(properColorName(value.value<QColor>()));
case QVariant::Double:
return doubleToString(value.toDouble());
case QVariant::Int:
case QVariant::LongLong:
case QVariant::UInt:
case QVariant::ULongLong:
return stringValue;
default:
return QString(QLatin1String("\"%1\"")).arg(escape(stringValue));
}
}
} else {
Q_ASSERT("Unknown property type");
return QString();
}
}
// TODO: this need to e updated for states
static bool compareProperty(const AbstractProperty &property1, const AbstractProperty &property2)
{
return (property1.name() == property2.name());
// && (property1.value().type() == property2.value().type());
// && (property1.value() == property2.value()));
}
bool ModelToTextMerger::isInHierarchy(const AbstractProperty &property) {
return property.isValid() && property.parentModelNode().isInHierarchy();
}
