Example #1
0
void ItemTreeViewImpl::copySelectedItemsSub(Item* item, ItemPtr& duplicated, set<Item*>& items)
{
    for(Item* childItem = item->childItem(); childItem; childItem = childItem->nextItem()){
        set<Item*>::iterator p = items.find(childItem);
        if(p != items.end()){
            ItemPtr duplicatedChild;
            if(childItem->isSubItem()){
                duplicatedChild = duplicated->findItem(childItem->name());
            } else {
                duplicatedChild = childItem->duplicate();
                if(duplicatedChild){
                    duplicated->addChildItem(duplicatedChild);
                }
            }
            if(duplicatedChild){
                copySelectedItemsSub(childItem, duplicatedChild, items);
            }
        }
    }
}
Example #2
0
void ItemTreeViewImpl::pasteItems()
{
    if(!copiedItemList.empty()){
        ItemPtr parentItem;
        if(selectedItemList.empty()){
            parentItem = rootItem;
        } else if(selectedItemList.size() == 1){
            parentItem = selectedItemList.front();
        }
        if(parentItem){
            for(size_t i=0; i < copiedItemList.size(); ++i){
                ItemPtr org = copiedItemList[i];
                ItemPtr duplicated = org->duplicateAll();
                if(duplicated){
                    copiedItemList[i] = duplicated;
                }
                parentItem->addChildItem(org, true); // paste the original items
            }
        }
    }
}
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);
}