ArchivePtr ItemTreeArchiver::store(ArchivePtr parentArchive, ItemPtr item)
{
    itemIdCounter = 0;
    return storeIter(parentArchive, item.get());
}
bool ItemTreeArchiver::restoreItemIter(Archive* archive, ItemPtr& parentItem)
{
    ItemPtr item;

    string pluginName;
    string className;

    if(!(archive->read("plugin", pluginName) && archive->read("class", className))) {
        messageView->putln(_("Archive is broken."));
        return false;
    }

    const char* actualPluginName = PluginManager::instance()->guessActualPluginName(pluginName);
    if(actualPluginName) {
        item = ItemManager::create(actualPluginName, className);
    }

    if(!item) {
        messageView->putln(
            format(_("Item type %1% of %2% cannot be restored. It's not a registered type."))
            % className % pluginName);
    } else {
        bool restored = false;
        string name;
        if(archive->read("name", name)) {

            item->setName(name);

            bool isRootItem = dynamic_pointer_cast<RootItem>(item);

            if(isRootItem) {
                item = parentItem;
                restored = true;
            } else {

                messageView->putln(format(_("Restoring %1% \"%2%\"")) % className % name);
                messageView->flush();

                YamlNodePtr dataNode = archive->find("data");

                if(!dataNode->isValid()) {
                    restored = true;

                } else if(dataNode->type() == YAML_MAPPING) {
                    Archive* dataArchive = static_cast<Archive*>(dataNode->toMapping());
                    dataArchive->inheritSharedInfoFrom(archive);
                    dataArchive->setCurrentParentItem(parentItem.get());
                    restored = item->restore(*dataArchive);
                }

                if(restored) {
                    parentItem->addChildItem(item);
                }
            }

            if(!restored) {
                messageView->putln(format(_("%1% \"%2%\" cannot be restored.")) % className % name);
                item = 0;
            } else {
                int id;
                if(archive->read("id", id) && (id >= 0)) {
                    archive->registerItemId(item.get(), id);
                }

                YamlSequencePtr children = archive->findSequence("children");
                if(children->isValid()) {
                    for(int i=0; i < children->size(); ++i) {
                        Archive* childArchive = dynamic_cast<Archive*>(children->get(i).toMapping());
                        childArchive->inheritSharedInfoFrom(archive);
                        restoreItemIter(childArchive, item);
                    }
                }
            }
        }
    }

    return (item);
}
Exemplo n.º 3
0
bool ItemTreeView::checkItem(ItemPtr item, bool checked, int id)
{
    return impl->checkItem(item.get(), checked, id);
}
Exemplo n.º 4
0
ItemPtr Item::clone()
{
    ItemPtr item = ItemPtr(new Item);
    *(item.get()) = *this;
    return item;
}
Exemplo n.º 5
0
bool ItemTreeView::isItemChecked(ItemPtr item, int id)
{
    return impl->isItemChecked(item.get(), id);
}