← Back to branch summary

~bzoltan/kubuntu-packaging/decouple_cmake_plugin

« back to all changes in this revision

Viewing changes to src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp

  • Committer: Timo Jyrinki
  • Date: 2013-11-15 12:25:23 UTC
  • mfrom: (1.1.28)
  • Revision ID: timo.jyrinki@canonical.com-20131115122523-i2kyamsu4gs2mu1m
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp
33
33
#include "variantproperty.h"
34
34
#include "nodeproperty.h"
35
35
#include <invalidmodelnodeexception.h>
36
 
#include "qmlmodelview.h"
 
36
#include "abstractview.h"
37
37
#include "nodeinstance.h"
38
38
#include "nodemetainfo.h"
39
39
#include "bindingproperty.h"
40
40
#include "nodelistproperty.h"
 
41
#include "nodeinstanceview.h"
41
42
 
42
43
namespace QmlDesigner {
43
44
 
53
54
 
54
55
        QmlPropertyChanges changeSet(currentState().propertyChanges(modelNode()));
55
56
        Q_ASSERT(changeSet.isValid());
56
 
        changeSet.modelNode().variantProperty(name) = value;
 
57
        changeSet.modelNode().variantProperty(name).setValue(value);
57
58
    }
58
59
}
59
60
 
63
64
        throw new InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
64
65
 
65
66
    if (isInBaseState()) {
66
 
        modelNode().bindingProperty(name) = expression; //basestate
 
67
        modelNode().bindingProperty(name).setExpression(expression); //basestate
67
68
    } else {
68
69
        modelNode().validId();
69
70
 
70
71
        QmlPropertyChanges changeSet(currentState().propertyChanges(modelNode()));
71
72
        Q_ASSERT(changeSet.isValid());
72
 
        changeSet.modelNode().bindingProperty(name) = expression;
 
73
        changeSet.modelNode().bindingProperty(name).setExpression(expression);
73
74
    }
74
75
}
75
76
 
76
77
QmlModelState QmlObjectNode::currentState() const
77
78
{
78
79
    if (isValid())
79
 
        return qmlModelView()->currentState();
 
80
        return QmlModelState(view()->currentStateNode());
80
81
    else
81
82
        return QmlModelState();
82
83
}
87
88
}
88
89
 
89
90
 
90
 
/*! \brief returns the value of a property based on an actual instance
91
 
The return value is not the value in the model, but the value of a real
92
 
instanciated instance of this object.
93
 
\return the value of this property based on the instance
94
 
 
 
91
/*!
 
92
    Returns the value of the property specified by \name that is based on an
 
93
    actual instance. The return value is not the value in the model, but the
 
94
    value of a real instantiated instance of this object.
95
95
*/
96
96
QVariant  QmlObjectNode::instanceValue(const PropertyName &name) const
97
97
{
129
129
 
130
130
NodeAbstractProperty QmlObjectNode::nodeAbstractProperty(const PropertyName &name) const
131
131
{
132
 
   return modelNode().nodeAbstractProperty(name);
 
132
    return modelNode().nodeAbstractProperty(name);
 
133
}
 
134
 
 
135
NodeAbstractProperty QmlObjectNode::defaultNodeAbstractProperty() const
 
136
{
 
137
    return modelNode().defaultNodeAbstractProperty();
133
138
}
134
139
 
135
140
NodeProperty QmlObjectNode::nodeProperty(const PropertyName &name) const
222
227
    return propertyChanges.modelNode().bindingProperty(name).expression();
223
228
}
224
229
 
225
 
/*! \brief returns if ObjectNode is the BaseState
226
 
 
227
 
\return true if the ObjectNode is in the BaseState
228
 
 
 
230
/*!
 
231
    Returns \c true if the ObjectNode is in the BaseState.
229
232
*/
230
233
bool QmlObjectNode::isInBaseState() const
231
234
{
232
235
    return currentState().isBaseState();
233
236
}
234
237
 
235
 
bool QmlObjectNode::canReparent() const
 
238
bool QmlObjectNode::instanceCanReparent() const
236
239
{
237
240
    return isInBaseState();
238
241
}
254
257
static void removeStateOperationsForChildren(const QmlObjectNode &node)
255
258
{
256
259
    if (node.isValid()) {
257
 
        foreach (const QmlModelStateOperation &stateOperation, node.allAffectingStatesOperations()) {
 
260
        foreach (QmlModelStateOperation stateOperation, node.allAffectingStatesOperations()) {
258
261
            stateOperation.modelNode().destroy(); //remove of belonging StatesOperations
259
262
        }
260
263
 
265
268
}
266
269
 
267
270
 
268
 
/*! \brief Deletes this objects ModeNode and its dependencies from the model
269
 
Every thing that belongs to this Object, the ModelNode and ChangeOperations
270
 
are deleted from the model.
271
 
 
 
271
/*!
 
272
    Deletes this object's node and its dependencies from the model.
 
273
    Everything that belongs to this Object, the ModelNode, and ChangeOperations
 
274
    is deleted from the model.
272
275
*/
273
276
void QmlObjectNode::destroy()
274
277
{
275
278
    if (!isValid())
276
279
        throw new InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
277
280
 
278
 
    foreach (const QmlModelStateOperation &stateOperation, allAffectingStatesOperations()) {
 
281
    foreach (QmlModelStateOperation stateOperation, allAffectingStatesOperations()) {
279
282
        stateOperation.modelNode().destroy(); //remove of belonging StatesOperations
280
283
    }
281
284
    removeStateOperationsForChildren(modelNode());
282
285
    modelNode().destroy();
283
286
}
284
287
 
285
 
/*! \brief Returns a list of all states that are affecting this object.
286
 
 
287
 
\return list of states affecting this object
 
288
/*!
 
289
    Returns a list of states the affect this object.
288
290
*/
289
291
 
290
292
QList<QmlModelState> QmlObjectNode::allAffectingStates() const
301
303
    return returnList;
302
304
}
303
305
 
304
 
/*! \brief Returns a list of all state operations that are affecting this object.
305
 
 
306
 
\return list of state operations affecting this object
 
306
/*!
 
307
    Returns a list of all state operations that affect this object.
307
308
*/
308
309
 
309
310
QList<QmlModelStateOperation> QmlObjectNode::allAffectingStatesOperations() const
320
321
    return returnList;
321
322
}
322
323
 
323
 
static QList<QmlItemNode> allFxItemsRecursive(const QmlItemNode &fxNode)
 
324
static QList<QmlItemNode> allQmlItemsRecursive(const QmlItemNode &qmlItemNode)
324
325
{
325
 
    QList<QmlItemNode> returnList;
326
 
 
327
 
    if (fxNode.isValid()) {
328
 
        returnList.append(fxNode);
329
 
        QList<QmlItemNode> allChildNodes;
330
 
        foreach (const ModelNode &node, fxNode.modelNode().allDirectSubModelNodes()) {
331
 
            if (QmlItemNode(node).isValid())
332
 
                allChildNodes.append(node);
333
 
        }
334
 
        foreach (const QmlItemNode &node, allChildNodes) {
335
 
            returnList.append(allFxItemsRecursive(node));
 
326
    QList<QmlItemNode> qmlItemNodeList;
 
327
 
 
328
    if (qmlItemNode.isValid()) {
 
329
        qmlItemNodeList.append(qmlItemNode);
 
330
 
 
331
        foreach (const ModelNode &modelNode, qmlItemNode.modelNode().allDirectSubModelNodes()) {
 
332
            if (QmlItemNode::isValidQmlItemNode(modelNode))
 
333
                qmlItemNodeList.append(allQmlItemsRecursive(modelNode));
336
334
        }
337
335
    }
338
 
    return returnList;
 
336
 
 
337
    return qmlItemNodeList;
339
338
}
340
339
 
341
340
QList<QmlModelState> QmlObjectNode::allDefinedStates() const
345
344
 
346
345
    QList<QmlModelState> returnList;
347
346
 
348
 
    QList<QmlItemNode> allFxItems;
349
 
 
350
 
    QmlItemNode rootNode(qmlModelView()->rootModelNode());
351
 
 
352
 
    if (rootNode.isValid())
353
 
        allFxItems.append(allFxItemsRecursive(rootNode));
354
 
 
355
 
    foreach (const QmlItemNode &item, allFxItems) {
 
347
    QList<QmlItemNode> allQmlItems;
 
348
 
 
349
    if (QmlItemNode::isValidQmlItemNode(view()->rootModelNode()))
 
350
        allQmlItems.append(allQmlItemsRecursive(view()->rootModelNode()));
 
351
 
 
352
    foreach (const QmlItemNode &item, allQmlItems) {
356
353
        returnList.append(item.states().allStates());
357
354
    }
358
355
 
360
357
}
361
358
 
362
359
 
363
 
/*! \brief Removes a variant property of this object from the model
364
 
 
 
360
/*!
 
361
    Removes a variant property of the object specified by \a name from the
 
362
    model.
365
363
*/
366
364
 
367
 
void  QmlObjectNode::removeVariantProperty(const PropertyName &name)
 
365
void  QmlObjectNode::removeProperty(const PropertyName &name)
368
366
{
369
367
    if (!isValid())
370
368
        throw new InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
378
376
    }
379
377
}
380
378
 
381
 
QList<ModelNode> toModelNodeList(const QList<QmlObjectNode> &fxObjectNodeList)
 
379
QList<ModelNode> toModelNodeList(const QList<QmlObjectNode> &qmlObjectNodeList)
382
380
{
383
381
    QList<ModelNode> modelNodeList;
384
382
 
385
 
    foreach (const QmlObjectNode &fxObjectNode, fxObjectNodeList)
386
 
        modelNodeList.append(fxObjectNode.modelNode());
 
383
    foreach (const QmlObjectNode &qmlObjectNode, qmlObjectNodeList)
 
384
        modelNodeList.append(qmlObjectNode.modelNode());
387
385
 
388
386
    return modelNodeList;
389
387
}
393
391
    QList<QmlObjectNode> qmlObjectNodeList;
394
392
 
395
393
    foreach (const ModelNode &modelNode, modelNodeList) {
396
 
        QmlObjectNode objectNode(modelNode);
397
 
        if (objectNode.isValid())
398
 
            qmlObjectNodeList.append(objectNode);
 
394
        if (QmlObjectNode::isValidQmlObjectNode(modelNode))
 
395
             qmlObjectNodeList.append(modelNode);
399
396
    }
400
397
 
401
398
    return qmlObjectNodeList;
408
405
 
409
406
QVariant QmlObjectNode::instanceValue(const ModelNode &modelNode, const PropertyName &name)
410
407
{
411
 
    QmlModelView *modelView = qobject_cast<QmlModelView*>(modelNode.view());
412
 
    if (!modelView)
413
 
        throw new InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
414
 
    Q_ASSERT(modelView->hasInstanceForModelNode(modelNode));
415
 
    return modelView->instanceForModelNode(modelNode).property(name);
 
408
    Q_ASSERT(modelNode.view()->nodeInstanceView()->hasInstanceForModelNode(modelNode));
 
409
    return modelNode.view()->nodeInstanceView()->instanceForModelNode(modelNode).property(name);
416
410
}
417
411
 
418
412
QString QmlObjectNode::generateTranslatableText(const QString &text)
427
421
 
428
422
bool QmlObjectNode::instanceHasBinding(const PropertyName &name) const
429
423
{
430
 
    QmlModelView *modelView = qobject_cast<QmlModelView*>(modelNode().view());
431
 
    if (!modelView)
432
 
        throw new InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
433
 
 
434
424
    return nodeInstance().hasBindingForProperty(name);
435
425
}
436
426
 
437
427
NodeInstance QmlObjectNode::nodeInstance() const
438
428
{
439
 
    return qmlModelView()->nodeInstanceView()->instanceForNode(modelNode());
 
429
    return nodeInstanceView()->instanceForModelNode(modelNode());
440
430
}
441
431
 
442
432
QmlObjectNode QmlObjectNode::nodeForInstance(const NodeInstance &instance) const
443
433
{
444
 
    return QmlObjectNode(ModelNode(instance.modelNode(), qmlModelView()));
 
434
    return QmlObjectNode(ModelNode(instance.modelNode(), view()));
445
435
}
446
436
 
447
437
QmlItemNode QmlObjectNode::itemForInstance(const NodeInstance &instance) const
448
438
{
449
 
    return QmlItemNode(ModelNode(instance.modelNode(), qmlModelView()));
 
439
    return QmlItemNode(ModelNode(instance.modelNode(), view()));
 
440
}
 
441
 
 
442
QmlObjectNode::QmlObjectNode()
 
443
    : QmlModelNodeFacade()
 
444
{
 
445
}
 
446
 
 
447
QmlObjectNode::QmlObjectNode(const ModelNode &modelNode)
 
448
    : QmlModelNodeFacade(modelNode)
 
449
{
 
450
}
 
451
 
 
452
bool QmlObjectNode::isValidQmlObjectNode(const ModelNode &modelNode)
 
453
{
 
454
    return isValidQmlModelNodeFacade(modelNode);
 
455
}
 
456
 
 
457
bool QmlObjectNode::isValid() const
 
458
{
 
459
    return isValidQmlObjectNode(modelNode());
450
460
}
451
461
 
452
462
bool QmlObjectNode::hasNodeParent() const
456
466
 
457
467
bool QmlObjectNode::hasInstanceParent() const
458
468
{
459
 
    return nodeInstance().parentId() >= 0 && qmlModelView()->nodeInstanceView()->hasInstanceForId(nodeInstance().parentId());
 
469
    return nodeInstance().parentId() >= 0 && nodeInstanceView()->hasInstanceForId(nodeInstance().parentId());
460
470
}
461
471
 
462
472
bool QmlObjectNode::hasInstanceParentItem() const
463
473
{
464
474
    return nodeInstance().parentId() >= 0
465
 
            && qmlModelView()->nodeInstanceView()->hasInstanceForId(nodeInstance().parentId())
466
 
            && QmlItemNode::isItemOrWindow(qmlModelView()->modelNodeForInternalId(nodeInstance().parentId()));
 
475
            && nodeInstanceView()->hasInstanceForId(nodeInstance().parentId())
 
476
            && QmlItemNode::isItemOrWindow(view()->modelNodeForInternalId(nodeInstance().parentId()));
467
477
}
468
478
 
469
479
 
475
485
QmlObjectNode QmlObjectNode::instanceParent() const
476
486
{
477
487
    if (hasInstanceParent())
478
 
        return nodeForInstance(qmlModelView()->nodeInstanceView()->instanceForId(nodeInstance().parentId()));
 
488
        return nodeForInstance(nodeInstanceView()->instanceForId(nodeInstance().parentId()));
479
489
 
480
490
    return QmlObjectNode();
481
491
}
483
493
QmlItemNode QmlObjectNode::instanceParentItem() const
484
494
{
485
495
    if (hasInstanceParentItem())
486
 
        return itemForInstance(qmlModelView()->nodeInstanceView()->instanceForId(nodeInstance().parentId()));
 
496
        return itemForInstance(nodeInstanceView()->instanceForId(nodeInstance().parentId()));
487
497
 
488
498
    return QmlItemNode();
489
499
}
503
513
    return modelNode().validId();
504
514
}
505
515
 
506
 
bool QmlObjectNode::hasDefaultProperty() const
 
516
bool QmlObjectNode::hasDefaultPropertyName() const
507
517
{
508
518
    return modelNode().metaInfo().hasDefaultProperty();
509
519
}
510
520
 
511
 
PropertyName QmlObjectNode::defaultProperty() const
 
521
PropertyName QmlObjectNode::defaultPropertyName() const
512
522
{
513
523
    return modelNode().metaInfo().defaultPropertyName();
514
524
}
515
525
 
516
526
void QmlObjectNode::setParent(QmlObjectNode newParent)
517
527
{
518
 
    if (newParent.hasDefaultProperty())
519
 
        newParent.modelNode().nodeAbstractProperty(newParent.defaultProperty()).reparentHere(modelNode());
 
528
    if (newParent.hasDefaultPropertyName())
 
529
        newParent.modelNode().defaultNodeAbstractProperty().reparentHere(modelNode());
520
530
}
521
531
 
522
532
QmlItemNode QmlObjectNode::toQmlItemNode() const