void GradientLineQmlAdaptor::setupGradient()
{
if (!active())
return;
ModelNode modelNode = m_itemNode.modelNode();
QLinearGradient newGradient;
QVector<QGradientStop> stops;
if (!modelNode.isValid())
return;
if (modelNode.hasBindingProperty(gradientName()))
return;
if (modelNode.hasProperty(gradientName())) { //gradient exists
ModelNode gradientNode = modelNode.nodeProperty(gradientName()).modelNode();
QList<ModelNode> stopList = gradientNode.nodeListProperty("stops").toModelNodeList();
foreach (const ModelNode &stopNode, stopList) {
QmlObjectNode stopObjectNode = stopNode;
if (stopObjectNode.isValid()) {
qreal position = stopObjectNode.modelValue("position").toReal();
QColor color = stopObjectNode.modelValue("color").value<QColor>();
stops.append( QPair<qreal, QColor>(position, color));
}
}
void NodeInstanceView::resetVerticalAnchors(const ModelNode &modelNode)
{
QList<BindingProperty> bindingList;
QList<VariantProperty> valueList;
if (modelNode.hasBindingProperty("yx"))
bindingList.append(modelNode.bindingProperty("yx"));
else if (modelNode.hasVariantProperty("y"))
valueList.append(modelNode.variantProperty("y"));
if (modelNode.hasBindingProperty("height"))
bindingList.append(modelNode.bindingProperty("height"));
else if (modelNode.hasVariantProperty("height"))
valueList.append(modelNode.variantProperty("height"));
if (!valueList.isEmpty())
nodeInstanceServer()->changePropertyValues(createChangeValueCommand(valueList));
if (!bindingList.isEmpty())
nodeInstanceServer()->changePropertyBindings(createChangeBindingCommand(bindingList));
}
static inline void backupPropertyAndRemove(ModelNode node, const QString &propertyName)
{
if (node.hasVariantProperty(propertyName)) {
node.setAuxiliaryData(auxDataString + propertyName, node.variantProperty(propertyName).value());
node.removeProperty(propertyName);
}
if (node.hasBindingProperty(propertyName)) {
node.setAuxiliaryData(auxDataString + propertyName, QmlItemNode(node).instanceValue(propertyName));
node.removeProperty(propertyName);
}
}
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;
}
bool QmlObjectNode::isAliasExported() const
{
if (modelNode().isValid() && !modelNode().id().isEmpty()) {
PropertyName modelNodeId = modelNode().id().toUtf8();
ModelNode rootModelNode = view()->rootModelNode();
Q_ASSERT(rootModelNode.isValid());
if (rootModelNode.hasBindingProperty(modelNodeId)
&& rootModelNode.bindingProperty(modelNodeId).isDynamic()
&& rootModelNode.bindingProperty(modelNodeId).expression().toUtf8() == modelNodeId)
return true;
}
return false;
}
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 StatesEditorModel::data(const QModelIndex &index, int role) const
{
if (index.parent().isValid() || index.column() != 0 || m_statesEditorView.isNull() || !m_statesEditorView->hasModelNodeForInternalId(index.internalId()))
return QVariant();
ModelNode stateNode;
if (index.internalId() > 0)
stateNode = m_statesEditorView->modelNodeForInternalId(index.internalId());
switch (role) {
case StateNameRole: {
if (index.row() == 0) {
return QString(tr("base state", "Implicit default state"));
} else {
if (stateNode.hasVariantProperty("name"))
return stateNode.variantProperty("name").value();
else
return QVariant();
}
}
case StateImageSourceRole: {
static int randomNumber = 0;
randomNumber++;
if (index.row() == 0)
return QString("image://qmldesigner_stateseditor/baseState-%1").arg(randomNumber);
else
return QString("image://qmldesigner_stateseditor/%1-%2").arg(index.internalId()).arg(randomNumber);
}
case InternalNodeId: return index.internalId();
case HasWhenCondition: return stateNode.isValid() && stateNode.hasProperty("when");
case WhenConditionString: {
if (stateNode.isValid() && stateNode.hasBindingProperty("when"))
return stateNode.bindingProperty("when").expression();
else
return QString();
}
}
return QVariant();
}
static void removeAliasExports(const QmlObjectNode &node)
{
PropertyName propertyName = node.id().toUtf8();
ModelNode rootNode = node.view()->rootModelNode();
bool hasAliasExport = !propertyName.isEmpty()
&& rootNode.isValid()
&& rootNode.hasBindingProperty(propertyName)
&& rootNode.bindingProperty(propertyName).isAliasExport();
if (hasAliasExport)
rootNode.removeProperty(propertyName);
foreach (const ModelNode &childNode, node.modelNode().directSubModelNodes()) {
removeAliasExports(childNode);
}
}
void NodeInstanceView::auxiliaryDataChanged(const ModelNode &node, const PropertyName &name, const QVariant &data)
{
if ((node.isRootNode() && (name == "width" || name == "height")) || name.endsWith(PropertyName("@NodeInstance"))) {
if (hasInstanceForModelNode(node)) {
NodeInstance instance = instanceForModelNode(node);
QVariant value = data;
if (value.isValid()) {
PropertyValueContainer container(instance.instanceId(), name, value, TypeName());
ChangeAuxiliaryCommand changeAuxiliaryCommand(QVector<PropertyValueContainer>() << container);
nodeInstanceServer()->changeAuxiliaryValues(changeAuxiliaryCommand);
} else {
if (node.hasVariantProperty(name)) {
PropertyValueContainer container(instance.instanceId(), name, node.variantProperty(name).value(), TypeName());
ChangeValuesCommand changeValueCommand(QVector<PropertyValueContainer>() << container);
nodeInstanceServer()->changePropertyValues(changeValueCommand);
} else if (node.hasBindingProperty(name)) {
PropertyBindingContainer container(instance.instanceId(), name, node.bindingProperty(name).expression(), TypeName());
ChangeBindingsCommand changeValueCommand(QVector<PropertyBindingContainer>() << container);
nodeInstanceServer()->changePropertyBindings(changeValueCommand);
}
}
}
}
}