void FormEditorView::nodeCreated(const ModelNode &createdNode)
{
QmlModelView::nodeCreated(createdNode);
ModelNode node(createdNode);
if (QmlItemNode(node).isValid()) //only setup QmlItems
setupFormEditorItemTree(QmlItemNode(node));
}
void FormEditorView::nodeCreated(const ModelNode &createdNode)
{
QmlModelView::nodeCreated(createdNode);
ModelNode node(createdNode);
//If the node has source for components/custom parsers we ignore it.
if (QmlItemNode(node).isValid() && node.nodeSourceType() == ModelNode::NodeWithoutSource) //only setup QmlItems
setupFormEditorItemTree(QmlItemNode(node));
}
void PropertyEditor::NodeType::setup(const QmlObjectNode &fxObjectNode, const QString &stateName, const QUrl &qmlSpecificsFile, PropertyEditor *propertyEditor)
{
if (!fxObjectNode.isValid())
return;
QDeclarativeContext *ctxt = m_view->rootContext();
if (fxObjectNode.isValid()) {
foreach (const PropertyName &propertyName, fxObjectNode.modelNode().metaInfo().propertyNames())
createPropertyEditorValue(fxObjectNode, propertyName, fxObjectNode.instanceValue(propertyName), &m_backendValuesPropertyMap, propertyEditor);
// className
PropertyEditorValue *valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(m_backendValuesPropertyMap.value("className")));
if (!valueObject)
valueObject = new PropertyEditorValue(&m_backendValuesPropertyMap);
valueObject->setName("className");
valueObject->setModelNode(fxObjectNode.modelNode());
valueObject->setValue(fxObjectNode.modelNode().simplifiedTypeName());
QObject::connect(valueObject, SIGNAL(valueChanged(QString,QVariant)), &m_backendValuesPropertyMap, SIGNAL(valueChanged(QString,QVariant)));
m_backendValuesPropertyMap.insert("className", QVariant::fromValue(valueObject));
// id
valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(m_backendValuesPropertyMap.value("id")));
if (!valueObject)
valueObject = new PropertyEditorValue(&m_backendValuesPropertyMap);
valueObject->setName("id");
valueObject->setValue(fxObjectNode.id());
QObject::connect(valueObject, SIGNAL(valueChanged(QString,QVariant)), &m_backendValuesPropertyMap, SIGNAL(valueChanged(QString,QVariant)));
m_backendValuesPropertyMap.insert("id", QVariant::fromValue(valueObject));
// anchors
m_backendAnchorBinding.setup(QmlItemNode(fxObjectNode.modelNode()));
ctxt->setContextProperty("anchorBackend", &m_backendAnchorBinding);
ctxt->setContextProperty("transaction", m_propertyEditorTransaction.data());
m_contextObject->setSpecificsUrl(qmlSpecificsFile);
m_contextObject->setStateName(stateName);
if (!fxObjectNode.isValid())
return;
ctxt->setContextProperty("propertyCount", QVariant(fxObjectNode.modelNode().properties().count()));
m_contextObject->setIsBaseState(fxObjectNode.isInBaseState());
m_contextObject->setSelectionChanged(false);
m_contextObject->setSelectionChanged(false);
NodeMetaInfo metaInfo = fxObjectNode.modelNode().metaInfo();
if (metaInfo.isValid()) {
m_contextObject->setMajorVersion(metaInfo.majorVersion());
m_contextObject->setMinorVersion(metaInfo.minorVersion());
} else {
m_contextObject->setMajorVersion(-1);
m_contextObject->setMinorVersion(-1);
}
} else {
//This method does the setup of the initial FormEditorItem tree in the scene
void FormEditorView::setupFormEditorItemTree(const QmlItemNode &qmlItemNode)
{
m_scene->addFormEditorItem(qmlItemNode);
foreach (const QmlObjectNode &nextNode, qmlItemNode.allDirectSubNodes()) //TODO instance children
if (QmlItemNode(nextNode).isValid())
setupFormEditorItemTree(nextNode.toQmlItemNode());
}
//This method does the setup of the initial FormEditorItem tree in the scene
void FormEditorView::setupFormEditorItemTree(const QmlItemNode &qmlItemNode)
{
m_scene->addFormEditorItem(qmlItemNode);
foreach (const QmlObjectNode &nextNode, qmlItemNode.allDirectSubNodes()) //TODO instance children
//If the node has source for components/custom parsers we ignore it.
if (QmlItemNode(nextNode).isValid() && nextNode.modelNode().nodeSourceType() == ModelNode::NodeWithoutSource)
setupFormEditorItemTree(nextNode.toQmlItemNode());
}
void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
{
if (QmlItemNode(qmlObjectNode).isInLayout()) {
static const PropertyNameList propertyNames = layoutAttachedPropertiesNames();
foreach (const PropertyName &propertyName, propertyNames) {
createPropertyEditorValue(qmlObjectNode, "Layout." + propertyName, properDefaultLayoutAttachedProperties(qmlObjectNode, propertyName), propertyEditor);
}
}
QWidget *ConnectionDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QWidget *widget = QStyledItemDelegate::createEditor(parent, option, index);
const ConnectionModel *connectionModel = qobject_cast<const ConnectionModel*>(index.model());
ConnectionComboBox *connectionComboBox = qobject_cast<ConnectionComboBox*>(widget);
if (!connectionModel) {
qWarning() << "ConnectionDelegate::createEditor no model";
return widget;
}
if (!connectionModel->connectionView()) {
qWarning() << "ConnectionDelegate::createEditor no connection view";
return widget;
}
if (!connectionComboBox) {
qWarning() << "ConnectionDelegate::createEditor no bindingComboBox";
return widget;
}
switch (index.column()) {
case ConnectionModel::TargetModelNodeRow: {
foreach (const ModelNode &modelNode, connectionModel->connectionView()->allModelNodes()) {
if (!modelNode.id().isEmpty()) {
connectionComboBox->addItem(modelNode.id());
}
}
} break;
case ConnectionModel::TargetPropertyNameRow: {
connectionComboBox->addItems(prependOnForSignalHandler(connectionModel->getSignalsForRow(index.row())));
} break;
case ConnectionModel::SourceRow: {
ModelNode rootModelNode = connectionModel->connectionView()->rootModelNode();
if (QmlItemNode::isValidQmlItemNode(rootModelNode) && !rootModelNode.id().isEmpty()) {
QString itemText = tr("Change to default state");
QString source = QString::fromLatin1("{ %1.state = \"\" }").arg(rootModelNode.id());
connectionComboBox->addItem(itemText, source);
connectionComboBox->disableValidator();
foreach (const QmlModelState &state, QmlItemNode(rootModelNode).states().allStates()) {
QString itemText = tr("Change state to %1").arg(state.name());
QString source = QString::fromLatin1("{ %1.state = \"%2\" }").arg(rootModelNode.id()).arg(state.name());
connectionComboBox->addItem(itemText, source);
}
}
connectionComboBox->disableValidator();
} break;
default: qWarning() << "ConnectionDelegate::createEditor column" << index.column();
}
QmlItemNode QmlItemNode::createQmlItemNode(AbstractView *view, const ItemLibraryEntry &itemLibraryEntry, const QPointF &position, QmlItemNode parentQmlItemNode)
{
if (!parentQmlItemNode.isValid())
parentQmlItemNode = QmlItemNode(view->rootModelNode());
Q_ASSERT(parentQmlItemNode.isValid());
NodeAbstractProperty parentProperty = parentQmlItemNode.defaultNodeAbstractProperty();
return QmlItemNode::createQmlItemNode(view, itemLibraryEntry, position, parentProperty);
}
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);
}
}
QmlItemNode QmlItemNode::createQmlItemNode(AbstractView *view, const ItemLibraryEntry &itemLibraryEntry, const QPointF &position, NodeAbstractProperty parentproperty)
{
QmlItemNode newQmlItemNode;
try {
RewriterTransaction transaction = view->beginRewriterTransaction(QByteArrayLiteral("QmlItemNode::createQmlItemNode"));
NodeMetaInfo metaInfo = view->model()->metaInfo(itemLibraryEntry.typeName());
int minorVersion = metaInfo.minorVersion();
int majorVersion = metaInfo.majorVersion();
typedef QPair<PropertyName, QString> PropertyBindingEntry;
QList<PropertyBindingEntry> propertyBindingList;
if (itemLibraryEntry.qmlSource().isEmpty()) {
QList<QPair<PropertyName, QVariant> > propertyPairList;
if (!position.isNull()) {
propertyPairList.append(qMakePair(PropertyName("x"), QVariant(qRound(position.x()))));
propertyPairList.append(qMakePair(PropertyName("y"), QVariant(qRound(position.y()))));
}
foreach (const PropertyContainer &property, itemLibraryEntry.properties()) {
if (property.type() == QStringLiteral("binding")) {
propertyBindingList.append(PropertyBindingEntry(property.name(), property.value().toString()));
} else {
propertyPairList.append(qMakePair(property.name(), property.value()));
}
}
newQmlItemNode = QmlItemNode(view->createModelNode(itemLibraryEntry.typeName(), majorVersion, minorVersion, propertyPairList));
} else {
newQmlItemNode = createQmlItemNodeFromSource(view, itemLibraryEntry.qmlSource(), position);
}
if (parentproperty.isValid())
parentproperty.reparentHere(newQmlItemNode);
if (!newQmlItemNode.isValid())
return newQmlItemNode;
newQmlItemNode.setId(view->generateNewId(itemLibraryEntry.name()));
if (!view->currentState().isBaseState()) {
newQmlItemNode.modelNode().variantProperty("opacity").setValue(0);
newQmlItemNode.setVariantProperty("opacity", 1);
}
foreach (const PropertyBindingEntry &propertyBindingEntry, propertyBindingList)
newQmlItemNode.modelNode().bindingProperty(propertyBindingEntry.first).setExpression(propertyBindingEntry.second);
Q_ASSERT(newQmlItemNode.isValid());
}
void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
{
if (QmlItemNode(qmlObjectNode).isInLayout()) {
static const PropertyNameList propertyNames =
{"alignment", "column", "columnSpan", "fillHeight", "fillWidth", "maximumHeight", "maximumWidth",
"minimumHeight", "minimumWidth", "preferredHeight", "preferredWidth", "row", "rowSpan",
"topMargin", "bottomMargin", "leftMargin", "rightMargin"};
foreach (const PropertyName &propertyName, propertyNames) {
createPropertyEditorValue(qmlObjectNode, "Layout." + propertyName, properDefaultLayoutAttachedProperties(qmlObjectNode, propertyName), propertyEditor);
}
}
QmlItemNode QmlModelView::createQmlItemNodeFromImage(const QString &imageName, const QPointF &position, QmlItemNode parentNode)
{
if (!parentNode.isValid())
parentNode = rootQmlItemNode();
if (!parentNode.isValid())
return QmlItemNode();
QmlItemNode newNode;
RewriterTransaction transaction = beginRewriterTransaction();
{
QList<QPair<QString, QVariant> > propertyPairList;
propertyPairList.append(qMakePair(QString("x"), QVariant( round(position.x(), 4))));
propertyPairList.append(qMakePair(QString("y"), QVariant( round(position.y(), 4))));
QString relativeImageName = imageName;
//use relative path
if (QFileInfo(model()->fileUrl().toLocalFile()).exists()) {
QDir fileDir(QFileInfo(model()->fileUrl().toLocalFile()).absolutePath());
relativeImageName = fileDir.relativeFilePath(imageName);
}
propertyPairList.append(qMakePair(QString("source"), QVariant(relativeImageName)));
newNode = createQmlItemNode("Qt/Image",4, 7, propertyPairList);
parentNode.nodeAbstractProperty("data").reparentHere(newNode);
Q_ASSERT(newNode.isValid());
QString id;
int i = 1;
QString name("image");
name.remove(QLatin1Char(' '));
do {
id = name + QString::number(i);
i++;
} while (hasId(id)); //If the name already exists count upwards
newNode.setId(id);
if (!currentState().isBaseState()) {
newNode.modelNode().variantProperty("opacity") = 0;
newNode.setVariantProperty("opacity", 1);
}
Q_ASSERT(newNode.isValid());
}
Q_ASSERT(newNode.isValid());
return newNode;
}
static inline QPointF getUpperLeftPosition(const QList<ModelNode> &modelNodeList)
{
QPointF postion(std::numeric_limits<qreal>::max(), std::numeric_limits<qreal>::max());
foreach (const ModelNode &modelNode, modelNodeList) {
if (QmlItemNode::isValidQmlItemNode(modelNode)) {
QmlItemNode qmlIitemNode = QmlItemNode(modelNode);
if (qmlIitemNode.instancePosition().x() < postion.x())
postion.setX(qmlIitemNode.instancePosition().x());
if (qmlIitemNode.instancePosition().y() < postion.y())
postion.setY(qmlIitemNode.instancePosition().y());
}
}
return postion;
}
static QList<QmlItemNode> allFxItemsRecursive(const QmlItemNode &fxNode)
{
QList<QmlItemNode> returnList;
if (fxNode.isValid()) {
returnList.append(fxNode);
QList<QmlItemNode> allChildNodes;
foreach (const ModelNode &node, fxNode.modelNode().allDirectSubModelNodes()) {
if (QmlItemNode(node).isValid())
allChildNodes.append(node);
}
foreach (const QmlItemNode &node, allChildNodes) {
returnList.append(allFxItemsRecursive(node));
}
virtual void updateContext()
{
defaultAction()->setSelectionContext(selectionContext());
if (selectionContext().isValid()) {
defaultAction()->setEnabled(isEnabled(selectionContext()));
defaultAction()->setVisible(isVisible(selectionContext()));
defaultAction()->setCheckable(true);
QmlItemNode itemNode = QmlItemNode(selectionContext().currentSingleSelectedNode());
if (itemNode.isValid())
defaultAction()->setChecked(itemNode.instanceValue("visible").toBool());
else
defaultAction()->setEnabled(false);
}
}
void DragTool::dropEvent(const QList<QGraphicsItem*> &/*itemList*/, QGraphicsSceneDragDropEvent *event)
{
if (canHandleMimeData(event->mimeData())) {
event->accept();
end(generateUseSnapping(event->modifiers()));
commitTransaction();
if (m_dragNode.isValid())
view()->setSelectedModelNode(m_dragNode);
m_dragNode = QmlItemNode();
view()->changeToSelectionTool();
}
}
void MoveManipulator::synchronizeParent(const QList<FormEditorItem*> &itemList, const ModelNode &parentNode)
{
bool snapperUpdated = false;
foreach (FormEditorItem *item, itemList) {
if (m_itemList.contains(item)) {
QmlItemNode parentItemNode = QmlItemNode(parentNode);
if (parentItemNode.isValid()) {
if (snapperUpdated == false && m_snapper.containerFormEditorItem() != m_view->scene()->itemForQmlItemNode(parentItemNode)) {
m_snapper.setContainerFormEditorItem(m_view->scene()->itemForQmlItemNode(parentItemNode));
m_snapper.setTransformtionSpaceFormEditorItem(m_snapper.containerFormEditorItem());
m_snapper.updateSnappingLines(m_itemList);
snapperUpdated = true;
}
}
}
}
}
AnchorLine QmlAnchors::instanceAnchor(AnchorLine::Type sourceAnchorLine) const
{
QPair<QString, NodeInstance> targetAnchorLinePair;
if (qmlItemNode().nodeInstance().hasAnchor("anchors.fill") && (sourceAnchorLine & AnchorLine::Fill)) {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor("anchors.fill");
targetAnchorLinePair.first = lineTypeToString(sourceAnchorLine);
} else if (qmlItemNode().nodeInstance().hasAnchor("anchors.centerIn") && (sourceAnchorLine & AnchorLine::Center)) {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor("anchors.centerIn");
targetAnchorLinePair.first = lineTypeToString(sourceAnchorLine);
} else {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor(anchorPropertyName(sourceAnchorLine));
}
AnchorLine::Type targetAnchorLine = propertyNameToLineType(targetAnchorLinePair.first);
if (targetAnchorLine == AnchorLine::Invalid )
return AnchorLine();
Q_ASSERT(targetAnchorLinePair.second.isValid());
return AnchorLine(QmlItemNode(qmlItemNode().nodeForInstance(targetAnchorLinePair.second)), targetAnchorLine);
}
virtual void updateContext()
{
defaultAction()->setSelectionContext(selectionContext());
if (selectionContext().isValid()) {
defaultAction()->setEnabled(isEnabled(selectionContext()));
defaultAction()->setVisible(isVisible(selectionContext()));
defaultAction()->setCheckable(true);
QmlItemNode itemNode = QmlItemNode(selectionContext().currentSingleSelectedNode());
if (itemNode.isValid()) {
bool flag = false;
if (itemNode.modelNode().hasProperty(m_propertyName)
|| itemNode.propertyAffectedByCurrentState(m_propertyName)) {
flag = itemNode.modelValue(m_propertyName).toBool();
}
defaultAction()->setChecked(flag);
} else {
defaultAction()->setEnabled(false);
}
}
}
AnchorLine QmlAnchors::instanceAnchor(AnchorLine::Type sourceAnchorLine) const
{
QPair<QString, qint32> targetAnchorLinePair;
if (qmlItemNode().nodeInstance().hasAnchor("anchors.fill") && (sourceAnchorLine & AnchorLine::Fill)) {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor("anchors.fill");
targetAnchorLinePair.first = lineTypeToString(sourceAnchorLine); // TODO: looks wrong
} else if (qmlItemNode().nodeInstance().hasAnchor("anchors.centerIn") && (sourceAnchorLine & AnchorLine::Center)) {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor("anchors.centerIn");
targetAnchorLinePair.first = lineTypeToString(sourceAnchorLine);
} else {
targetAnchorLinePair = qmlItemNode().nodeInstance().anchor(anchorPropertyName(sourceAnchorLine));
}
AnchorLine::Type targetAnchorLine = propertyNameToLineType(targetAnchorLinePair.first);
if (targetAnchorLine == AnchorLine::Invalid )
return AnchorLine();
if (targetAnchorLinePair.second < 0) //there might be no node instance for the parent
return AnchorLine();
return AnchorLine(QmlItemNode(qmlItemNode().nodeForInstance(qmlItemNode().qmlModelView()->nodeInstanceView()->instanceForId(targetAnchorLinePair.second))), targetAnchorLine);
}
AnchorLine::AnchorLine()
: m_qmlItemNode(QmlItemNode())
, m_type(AnchorLineInvalid)
{}
QmlItemNode QmlModelView::createQmlItemNodeFromImage(const QString &imageName, const QPointF &position, QmlItemNode parentNode)
{
if (!parentNode.isValid())
parentNode = rootQmlItemNode();
if (!parentNode.isValid())
return QmlItemNode();
QmlItemNode newNode;
RewriterTransaction transaction = beginRewriterTransaction();
{
const QString newImportUrl = QLatin1String("QtQuick");
const QString newImportVersion = QLatin1String("1.0");
Import newImport = Import::createLibraryImport(newImportUrl, newImportVersion);
foreach (const Import &import, model()->imports()) {
if (import.isLibraryImport()
&& import.url() == newImport.url()
&& import.version() == newImport.version()) {
// reuse this import
newImport = import;
break;
}
}
if (!model()->imports().contains(newImport)) {
model()->changeImports(QList<Import>() << newImport, QList<Import>());
}
QList<QPair<QString, QVariant> > propertyPairList;
propertyPairList.append(qMakePair(QString("x"), QVariant( round(position.x(), 4))));
propertyPairList.append(qMakePair(QString("y"), QVariant( round(position.y(), 4))));
QString relativeImageName = imageName;
//use relative path
if (QFileInfo(model()->fileUrl().toLocalFile()).exists()) {
QDir fileDir(QFileInfo(model()->fileUrl().toLocalFile()).absolutePath());
relativeImageName = fileDir.relativeFilePath(imageName);
}
propertyPairList.append(qMakePair(QString("source"), QVariant(relativeImageName)));
newNode = createQmlItemNode("QtQuick.Image", 1, 0, propertyPairList);
parentNode.nodeAbstractProperty("data").reparentHere(newNode);
Q_ASSERT(newNode.isValid());
QString id;
int i = 1;
QString name("image");
name.remove(QLatin1Char(' '));
do {
id = name + QString::number(i);
i++;
} while (hasId(id)); //If the name already exists count upwards
newNode.setId(id);
if (!currentState().isBaseState()) {
newNode.modelNode().variantProperty("opacity") = 0;
newNode.setVariantProperty("opacity", 1);
}
Q_ASSERT(newNode.isValid());
}
Q_ASSERT(newNode.isValid());
return newNode;
}
QmlItemNode QmlItemNode::createQmlItemNode(AbstractView *view, const ItemLibraryEntry &itemLibraryEntry, const QPointF &position, QmlItemNode parentQmlItemNode)
{
if (!parentQmlItemNode.isValid())
parentQmlItemNode = QmlItemNode(view->rootModelNode());
Q_ASSERT(parentQmlItemNode.isValid());
QmlItemNode newQmlItemNode;
try {
RewriterTransaction transaction = view->beginRewriterTransaction();
NodeMetaInfo metaInfo = view->model()->metaInfo(itemLibraryEntry.typeName());
int minorVersion = metaInfo.minorVersion();
int majorVersion = metaInfo.majorVersion();
if (itemLibraryEntry.typeName().contains('.')) {
const QString newImportUrl = itemLibraryEntry.requiredImport();
if (!itemLibraryEntry.requiredImport().isEmpty()) {
const QString newImportVersion = QString("%1.%2").arg(QString::number(itemLibraryEntry.majorVersion()), QString::number(itemLibraryEntry.minorVersion()));
Import newImport = Import::createLibraryImport(newImportUrl, newImportVersion);
if (itemLibraryEntry.majorVersion() == -1 && itemLibraryEntry.minorVersion() == -1)
newImport = Import::createFileImport(newImportUrl, QString());
else
newImport = Import::createLibraryImport(newImportUrl, newImportVersion);
foreach (const Import &import, view->model()->imports()) {
if (import.isLibraryImport()
&& import.url() == newImport.url()
&& import.version() == newImport.version()) {
// reuse this import
newImport = import;
break;
}
}
if (!view->model()->hasImport(newImport, true, true))
view->model()->changeImports(QList<Import>() << newImport, QList<Import>());
}
}
if (itemLibraryEntry.qmlSource().isEmpty()) {
QList<QPair<PropertyName, QVariant> > propertyPairList;
propertyPairList.append(qMakePair(PropertyName("x"), QVariant(qRound(position.x()))));
propertyPairList.append(qMakePair(PropertyName("y"), QVariant(qRound(position.y()))));
foreach (const PropertyContainer &property, itemLibraryEntry.properties())
propertyPairList.append(qMakePair(property.name(), property.value()));
newQmlItemNode = QmlItemNode(view->createModelNode(itemLibraryEntry.typeName(), majorVersion, minorVersion, propertyPairList));
} else {
newQmlItemNode = createQmlItemNodeFromSource(view, itemLibraryEntry.qmlSource(), position);
}
if (parentQmlItemNode.hasDefaultPropertyName())
parentQmlItemNode.nodeAbstractProperty(parentQmlItemNode.defaultPropertyName()).reparentHere(newQmlItemNode);
if (!newQmlItemNode.isValid())
return newQmlItemNode;
newQmlItemNode.setId(view->generateNewId(itemLibraryEntry.name()));
if (!view->currentState().isBaseState()) {
newQmlItemNode.modelNode().variantProperty("opacity").setValue(0);
newQmlItemNode.setVariantProperty("opacity", 1);
}
Q_ASSERT(newQmlItemNode.isValid());
}
