C++ TreeNode::addNode方法代码示例

void Qtilities::Testing::TestObserver::testTreeChildrenContainment() {
    // Example tree using tree node classes to simplify test:
    QList<QObject*> children;
    TreeNode* rootNode = new TreeNode("Root");
    TreeNode* parentNode1 = rootNode->addNode("Parent 1");
    children << parentNode1;
    TreeNode* parentNode2 = rootNode->addNode("Parent 2");
    children << parentNode2;
    children << parentNode1->addItem("Child 1");
    children << parentNode1->addItem("Child 2");
    children << parentNode2->addItem("Child 3");
    children << parentNode2->addItem("Child 4");
    TreeItem* item = parentNode2->addItem("Child 5");
    children << item;

    // Now create and add a contained observer:
    TreeNode* containedNode = new TreeNode("Contained Node");
    children << containedNode;
    children << containedNode->addItem("Contained Item 1");
    children << containedNode->addItem("Contained Item 2");
    children << containedNode->addItem("Contained Item 3");

    containedNode->setParent(item);

    QList<QObject*> children_verify = rootNode->treeChildren();
    foreach (QObject* obj, children)
        QVERIFY(children_verify.contains(obj) == true);
}

void Qtilities::Testing::TestObserverRelationalTable::testVisitorIDs() {
    QList<QObject*> children;
    TreeNode* rootNode = new TreeNode("Root");
    TreeNode* parentNode1 = rootNode->addNode("Parent 1");
    children << parentNode1;
    TreeNode* parentNode2 = rootNode->addNode("Parent 2");
    children << parentNode2;
    children << parentNode1->addItem("Child 1");
    children << parentNode1->addItem("Child 2");
    children << parentNode2->addItem("Child 3");
    children << parentNode2->addItem("Child 4");
    children << parentNode2->addItem("Child 5");

    // The VISITOR_ID property should not exist on any objects:
    foreach (QObject* obj, children)
        QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == false);

    // Construct relational table:
    ObserverRelationalTable* table = new ObserverRelationalTable(rootNode);

    // Now check that all children got the VISITOR_ID property:
    foreach (QObject* obj, children)
        QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == true);

    // Now delete the table:
    delete table;

    // Now check that the VISITOR_ID property was removed from all objects:
    foreach (QObject* obj, children)
        QVERIFY(ObjectManager::propertyExists(obj,qti_prop_VISITOR_ID) == false);
}

void Qtilities::Testing::TestObserverRelationalTable::testCompare() {
    //LOG_INFO("TestObserverRelationalTable::testCompare() start:");
    // Remember for the same observers use compare(), for different observer use diff()
    TreeNode* observerA = new TreeNode("Observer A");
    TreeNode* parentNode1 = observerA->addNode("Parent 1");
    TreeNode* parentNode2 = observerA->addNode("Parent 2");
    parentNode1->addItem("Child 1");
    parentNode1->addItem("Child 2");
    parentNode2->addItem("Child 3");
    parentNode2->addItem("Child 4");

    ObserverRelationalTable tableA(observerA);
    ObserverRelationalTable tableB(observerA);
    QVERIFY(tableA.compare(tableB) == true);

    TreeItem* shared_item = parentNode2->addItem("Child 5");

    // The tables should not have changed yet:
    QVERIFY(tableA.compare(tableB) == true);
    tableA.refresh();
    // Now A should be up to date and B not:
    QVERIFY(tableA.compare(tableB) == false);
    tableB.refresh();
    // Now both should be up to date:
    QVERIFY(tableA.compare(tableB) == true);

    // Check difference in object relationships
    parentNode1->addItem(shared_item);
    tableA.refresh();
    QVERIFY(tableA.compare(tableB) == false);
    tableB.refresh();
    QVERIFY(tableA.compare(tableB) == true);
    //LOG_INFO("TestObserverRelationalTable::testCompare() end:");
}

int main(int argc, char *argv[])
{
    QtilitiesApplication a(argc, argv);
    QtilitiesApplication::setOrganizationName("YourOrganization");
    QtilitiesApplication::setOrganizationDomain("YourDomain");
    QtilitiesApplication::setApplicationName("My Application");
    QtilitiesApplication::setApplicationVersion("1.0");

    // Set the application export version:
    QtilitiesApplication::setApplicationExportVersion(0);

    // We need to set a QWidget as the application's main window in order for proxy actions to work:
    QWidget* proxy_widget = new QWidget;
    QtilitiesApplication::setMainWindow(proxy_widget);

    // Register our VersionDetails class in the Qtilities factory:
    FactoryItemID version_info_id("Version Details");
    OBJECT_MANAGER->registerFactoryInterface(&VersionDetails::factory,version_info_id);

    // Next create a TreeNode with a couple of our classes attached to it:
    TreeNode* node = new TreeNode("TestNode");
    VersionDetails* ver1 = new VersionDetails;
    ver1->setDescriptionBrief("Version 1 Brief");
    ver1->setDescriptionDetailed("Version 1 Brief");
    ver1->setVersionMajor(0);
    ver1->setVersionMinor(0);
    VersionDetails* ver2 = new VersionDetails;
    ver2->setDescriptionBrief("Version 2 Brief");
    ver2->setDescriptionDetailed("Version 2 Brief");
    ver2->setVersionMajor(1);
    ver2->setVersionMinor(2);
    node->attachSubject(ver1);
    node->attachSubject(ver2);
    node->addNode("NewNode");

    // Next export the node to a file:
    node->saveToFile("Output_Version_0.xml");
    node->setApplicationExportVersion(1);
    node->saveToFile("Output_Version_1.xml");

    ObserverWidget* view = new ObserverWidget(node);
    view->show();
    return a.exec();
}

void Qtilities::Testing::TestSubjectIterator::testIterationComplex() {
    TreeNode node;
    TreeNode* nodeA = node.addNode("A");
    TreeNode* nodeB = node.addNode("B");
    nodeA->addItem("1");
    TreeItem* shared_item = nodeA->addItem("2");
    nodeA->addItem("3");
    nodeB->addItem("4");
    nodeB->addItem("5");
    nodeB->attachSubject(shared_item);
    nodeB->addItem("6");

    // If we want to iterate through the subjects in nodeA:
    SubjectIterator<QObject> itrA(nodeA,SubjectIterator<QObject>::IterateChildren);
    QVERIFY(itrA.current() != 0);

    // In this case item1 will be skipped:
    QStringList testListA;
    testListA << itrA.current()->objectName();
    while (itrA.hasNext()) {
        testListA << itrA.next()->objectName();
    }

    QCOMPARE(testListA.count(), 3);
    QCOMPARE(testListA.at(0), QString("1"));
    QCOMPARE(testListA.at(1), QString("2"));
    QCOMPARE(testListA.at(2), QString("3"));

    // If we want to iterate through the subjects in nodeB:
    SubjectIterator<QObject> itrB(nodeB,SubjectIterator<QObject>::IterateChildren);

    // In this case item1 will be skipped:
    QStringList testListB;
    testListB << itrB.current()->objectName();
    while (itrB.hasNext()) {
        testListB << itrB.next()->objectName();
    }

    QCOMPARE(testListB.count(), 4);
    QCOMPARE(testListB.at(0), QString("4"));
    QCOMPARE(testListB.at(1), QString("5"));
    QCOMPARE(testListB.at(2), QString("2"));
    QCOMPARE(testListB.at(3), QString("6"));

    // If we want to iterate through the subjects in nodeB:
    SubjectIterator<QObject> itrC(shared_item,nodeB);

    // In this case item1 will be skipped:
    QStringList testListC;
    testListC << itrC.current()->objectName();
    while (itrC.hasNext()) {
        testListC << itrC.next()->objectName();
    }

    QCOMPARE(testListC.count(), 2);
    QCOMPARE(testListC.at(0), QString("2"));
    QCOMPARE(testListC.at(1), QString("6"));

    // If we want to iterate through the subjects in nodeB:
    SubjectIterator<QObject> itrD(shared_item,nodeA);

    // In this case item1 will be skipped:
    QStringList testListD;
    testListD << itrD.current()->objectName();
    while (itrD.hasNext()) {
        testListD << itrD.next()->objectName();
    }

    QCOMPARE(testListD.count(), 2);
    QCOMPARE(testListD.at(0), QString("2"));
    QCOMPARE(testListD.at(1), QString("3"));
}

int main(int argc, char *argv[])
{
    QtilitiesApplication a(argc, argv);
    QtilitiesApplication::setOrganizationName("Jaco Naude");
    QtilitiesApplication::setOrganizationDomain("Qtilities");
    QtilitiesApplication::setApplicationName("Qtilities Tester");
    QtilitiesApplication::setApplicationVersion(QtilitiesApplication::qtilitiesVersionString());

    // Create the observer widget in tree mode:
    ObserverWidget* observer_widget = new ObserverWidget;
    observer_widget->resize(600,850);
    QtilitiesApplication::setMainWindow(observer_widget);

    Log->setLoggerSessionConfigPath(QtilitiesApplication::applicationSessionPath());
    LOG_INITIALIZE();

    TreeNode* rootNodeCategorized = new TreeNode("Root");
    rootNodeCategorized->enableCategorizedDisplay();
    // TODO: This breaks the toolbar for some reason... Looks like a display issue since it only happens in QTabWidget:
    rootNodeCategorized->displayHints()->setDisplayFlagsHint(ObserverHints::ItemView | ObserverHints::ActionToolBar);
    rootNodeCategorized->displayHints()->setActionHints(ObserverHints::ActionAllHints);
    rootNodeCategorized->displayHints()->setCategoryEditingFlags(ObserverHints::CategoriesEditableAllLevels | ObserverHints::CategoriesAcceptSubjectDrops);
    rootNodeCategorized->displayHints()->setDragDropHint(ObserverHints::AllowDrags);
    rootNodeCategorized->addItem("Child 1",QtilitiesCategory("Category 1::A",QString("::")));
    rootNodeCategorized->addItem("Child 2",QtilitiesCategory("Category 1::B",QString("::")));
    rootNodeCategorized->addItem("Child 3");
    rootNodeCategorized->addItem("Child 4",QtilitiesCategory("Category 2"));
    TreeItem* modified_item = rootNodeCategorized->addItem("Child 5",QtilitiesCategory("Category 2"));
    rootNodeCategorized->displayHints()->setModificationStateDisplayHint(ObserverHints::CharacterModificationStateDisplay);
    modified_item->setModificationState(true);

    // Init and show the observer widget:
    observer_widget->setObserverContext(rootNodeCategorized);
    observer_widget->initialize();

    // Test the tree model:
    new ModelTest(observer_widget->proxyModel());
    // Test the table model:
    //new ModelTest(observer_widget->tableModel());

    observer_widget->show();

    QStringList items;
    items << "A" << "B" << "C";
    rootNodeCategorized->addItems(items);

    TreeNode* nodeA = rootNodeCategorized->addNode("Node A");
    nodeA->copyHints(rootNodeCategorized->displayHints());
    TreeNode* nodeB = rootNodeCategorized->addNode("Node B");
    nodeB->copyHints(rootNodeCategorized->displayHints());

    nodeA->addItem("Child 1",QtilitiesCategory("Category 3::A",QString("::")));
    nodeA->addItem("Child 2",QtilitiesCategory("Category 4::B",QString("::")));
    nodeA->addItem("Child 3");
    nodeA->addItem("Child 4",QtilitiesCategory("Category 5"));

    nodeB->addItem("Child 1",QtilitiesCategory("Category 6::A",QString("::")));
    nodeB->addItem("Child 2",QtilitiesCategory("Category 7::B",QString("::")));
    nodeB->addItem("Child 3");
    nodeB->addItem("Child 4",QtilitiesCategory("Category 8"));

    return a.exec();
}