myvtm/Framework/spshell/Widgets/treemodel/treeitem.cpp

#include "treeitem.h"
#include <QDebug>

#define tr(x) x

TreeItem::TreeItem(const QVector<QVariant> &data, TreeItem *parent)
    : itemData(data),
      parentItem(parent),itemType(UnKnown),mSettings(nullptr)
{}

TreeItem::~TreeItem()
{
    qDeleteAll(childItems);
}

TreeItem *TreeItem::child(int number)
{
    if (number < 0 || number >= childItems.size())
        return nullptr;
    return childItems.at(number);
}

int TreeItem::childCount() const
{
    return childItems.count();
}

int TreeItem::childNumber() const
{
    if (parentItem)
        return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));
    return 0;
}

int TreeItem::columnCount() const
{
    return itemData.count();
}

QVariant TreeItem::data(int column) const
{
    if (column < 0 || column >= itemData.size())
        return QVariant();
    return itemData.at(column);
}

bool TreeItem::insertChildren(int position, int count, int columns, TreeItemType type)
{
    Q_UNUSED(type);
    qDebug() << "Enter TreeItem::insertChildren " << position << " " << count << " " << columns << endl;
    if (position < 0 || position > childItems.size())
        return false;

    for (int row = 0; row < count; ++row) {
        QVector<QVariant> data(columns);
        TreeItem *item = new TreeItem(data, this);
        if(this->itemType == TreeItemType::Root)
            item->setItemType(TreeItemType::Section);
        else if(this->itemType == TreeItemType::Section)
            item->setItemType(TreeItemType::Key);
        childItems.insert(position, item);
    }
    return true;
}

bool TreeItem::insertColumns(int position, int columns)
{
    qDebug() << "Enter TreeItem::insertColumns " << position << " " << columns << endl;
    if (position < 0 || position > itemData.size())
        return false;

    for (int column = 0; column < columns; ++column)
        itemData.insert(position, QVariant());

    for (TreeItem *child : qAsConst(childItems))
        child->insertColumns(position, columns);

    return true;
}

QSettings* TreeItem::getSettings()
{
    if(parentItem)
        return parentItem->getSettings();

    return mSettings;
}

TreeItem *TreeItem::parent()
{
    return parentItem;
}

bool TreeItem::removeChildren(int position, int count)
{
    qDebug() << "Enter TreeItem::removeChildren " << data(0) << " " << position << " " << count << endl;
    if (position < 0 || position + count > childItems.size())
        return false;

    for (int row = 0; row < count; ++row)
    {
        TreeItem* item = childItems.takeAt(position);
        if(item != nullptr) {
            qDebug() << "data: " << row << " " << item->data(DEFAULT_KEY_COLUMN) << " " << item->data(DEFAULT_VALUE_COLUMN) << endl;
            QSettings* settings = getSettings();
            if(settings) {
                if(item->getItemType() == Key)
                {
                    settings->beginGroup(data(DEFAULT_KEY_COLUMN).toString());
                    settings->remove(item->data(DEFAULT_KEY_COLUMN).toString());
                    settings->endGroup();

                } else if(item->getItemType() == Section)
                {
                    settings->beginGroup(item->data(DEFAULT_SECTION_COLUMN).toString());
                    settings->remove("");
                    settings->endGroup();
                }
            }

        }
        delete item;
    }

    return true;
}

bool TreeItem::removeColumns(int position, int columns)
{
    qDebug() << "Enter TreeItem::removeColumns " << position << " " << columns << endl;
    if (position < 0 || position + columns > itemData.size())
        return false;

    for (int column = 0; column < columns; ++column)
        itemData.remove(position);

    for (TreeItem *child : qAsConst(childItems))
        child->removeColumns(position, columns);

    return true;
}

static QVariant getValidVariant(const QVariant& value)
{
    QVariant result = value;
    if(value == QVariant(DEFAULT_KEY_VALUE)
            || value == QVariant(DEFAULT_SECTION_VALUE)
            || value == QVariant(DEFAULT_UNKNOWN_VALUE)
            || value == QVariant("\t")) {
        result = QVariant();
    }
    return result;
}

static bool isValidVariant(const QVariant& value)
{
    return (!value.isNull() && value.isValid());
}


bool TreeItem::setData(int column, const QVariant &value)
{
    qDebug() << "Enter TreeItem::setData " << column << " " << value << endl;

    if (column < 0 || column >= itemData.size())
        return false;
    const QVariant oldValue = getValidVariant(itemData[column]);
    itemData[column] = value;
    const QVariant newValue = getValidVariant(itemData[column]);
    QVariant brotherValue = getValidVariant(itemData[column == DEFAULT_KEY_COLUMN ? DEFAULT_VALUE_COLUMN : DEFAULT_KEY_COLUMN]);

    QSettings* settings = getSettings();
    if(oldValue != value && settings != nullptr)
    {
        if(itemType == Key)
        {
            QString sectionName = parentItem->data(DEFAULT_SECTION_COLUMN).toString();
            settings->beginGroup(sectionName);
            qDebug() << "set key : " << sectionName << " " << oldValue.toString() << " " << newValue.toString() << " " << brotherValue.toString() << endl;
            if(column == DEFAULT_KEY_COLUMN) { //change the key
                if(isValidVariant(newValue)) {
                    settings->setValue(newValue.toString(), brotherValue);
                    if(isValidVariant(oldValue)) settings->remove(oldValue.toString());
                }
            } else if(column == DEFAULT_VALUE_COLUMN) {//change the value
                if(isValidVariant(brotherValue)) {
                    settings->setValue(brotherValue.toString(), newValue);
                }
            }
            settings->endGroup();
        }
        else if(itemType == Section && column == DEFAULT_SECTION_COLUMN)
        {
            qDebug() << "set Section : "  << oldValue.toString() << " " << newValue.toString() << endl;
            if(childCount() > 0) {
                settings->beginGroup(newValue.toString());
                for (TreeItem *child : qAsConst(childItems))
                    settings->setValue(child->data(DEFAULT_KEY_COLUMN).toString()
                                       , child->data(DEFAULT_VALUE_COLUMN));
                settings->endGroup();
            }
            if(isValidVariant(oldValue)) {
                settings->beginGroup(oldValue.toString());
                settings->remove("");
                settings->endGroup();
            }
        }
    }
    return true;
}