ItemFileIO.h

Go to the documentation of this file.

#ifndef CNOID_BASE_ITEM_FILE_IO_H
#define CNOID_BASE_ITEM_FILE_IO_H
 
#include "ItemList.h"
#include <cnoid/Referenced>
#include <string>
#include <vector>
#include "exportdecl.h"
 
class QWidget;
 
namespace cnoid {
 
class Item;
class ItemManager;
class ItemFileIOExtenderBase;
class ItemFileDialog;
class Mapping;
 
class CNOID_EXPORT ItemFileIO : public Referenced
{
public:
    enum API {
        Load = 1 << 0,
        Options = 1 << 1,
        OptionPanelForLoading = 1 << 2,
        Save = 1 << 3,
        OptionPanelForSaving = 1 << 4,
    };
    enum InterfaceLevel { Standard, Conversion, Internal };
    enum InvocationType { Direct, Dialog, DragAndDrop };
    class Impl;
 
public:
    ~ItemFileIO();
 
    bool isFormat(const std::string& id) const;
    int api() const;
    void setApi(int apiSet);
    bool hasApi(int api) const;
    void setCaption(const std::string& caption);
    const std::string& caption() const;
    void setFileTypeCaption(const std::string& caption);
    const std::string& fileTypeCaption() const;
    void addFormatIdAlias(const std::string& formatId);
    void addExtensions(const std::vector<std::string>& extensions);
 
    // deprecated. This is internally used for specifing SceneItem's extensions dynamically.
    // The dynamic extension specification should be achieved by a signal to update the
    // extensions and usual the registerExtensions function.
    void setExtensionFunction(std::function<std::string()> func);
 
    std::vector<std::string> extensions() const;
    
    void setInterfaceLevel(InterfaceLevel level);
    int interfaceLevel() const;
    
    virtual Item* createItem() = 0;
 
    // Set the invocation type before calling the loadItem or saveItem function
    // if the invocation type is not "Direct".
    void setInvocationType(int type);
 
    // Load API
    Item* loadItem(
        const std::string& filename,
        Item* parentItem = nullptr, bool doAddition = true, Item* nextItem = nullptr,
        const Mapping* options = nullptr);
 
    bool loadItem(
        Item* item, const std::string& filename,
        Item* parentItem = nullptr, bool doAddition = true, Item* nextItem = nullptr,
        const Mapping* options = nullptr);
 
    // Save API
    bool saveItem(Item* item, const std::string& filename, const Mapping* options = nullptr);
    
    // Options API
    virtual void resetOptions();
    virtual void storeOptions(Mapping* options);
    virtual bool restoreOptions(const Mapping* options);
    
    // OptionPanelForLoading API
    virtual QWidget* getOptionPanelForLoading();
    virtual void fetchOptionPanelForLoading();
 
    // OptionPanelForPostLoading API (pending)
    //virtual QWidget* getOptionPanelForPostLoading(Item* item);
    //virtual void fetchOptionPanelForPostLoading(Item* item);
    //virtual bool doPostProcessForLoading(Item* item);
 
    // OptionPanelForSaving API
    virtual QWidget* getOptionPanelForSaving(Item* item);
    virtual void fetchOptionPanelForSaving();
 
    Item* parentItem();
    int invocationType() const;
 
    bool isRegisteredForSingletonItem() const;
    Item* findSingletonItemInstance() const;
 
    void setItemClassInfo(Referenced* info);
    const Referenced* itemClassInfo() const;
 
    static std::vector<std::string> separateExtensions(const std::string& multiExtString);
 
protected:
    ItemFileIO(const std::string& formatId, int api);
    ItemFileIO(const ItemFileIO& org);
    ItemFileIO();
    void copyFrom(const ItemFileIO& org);
    
    void setExtension(const std::string& extension);
    void setExtensions(const std::vector<std::string>& extensions);
 
    // Load API
    virtual bool load(Item* item, const std::string& filename);
 
    // Save API
    virtual bool save(Item* item, const std::string& filename);
    
    std::ostream& os();
    void putWarning(const std::string& message);
    void putError(const std::string& message);
 
    void setActuallyLoadedItem(Item* item);
    
private:
    Impl* impl;
    friend class ItemManager;
    friend class ItemFileIoExtenderBase;
    friend class ItemFileDialog;
};
 
typedef ref_ptr<ItemFileIO> ItemFileIOPtr;
 
template<class ItemType>
class ItemFileIoBase : public ItemFileIO
{
public:
    ItemFileIoBase(const std::string& formatId, int api)
        : ItemFileIO(formatId, api) {
    }
    virtual Item* createItem() override {
        return new ItemType;
    }
    virtual bool load(Item* item, const std::string& filename) override final {
        if(auto derived = dynamic_cast<ItemType*>(item)){
            return load(derived, filename);
        }
        return false;
    }
    virtual bool load(ItemType* /* item */, const std::string& /* filename */) {
        return false;
    }
    virtual bool save(Item* item, const std::string& filename) override final {
        if(auto derived = dynamic_cast<ItemType*>(item)){
            return save(derived, filename);
        }
        return false;
    }
    virtual bool save(ItemType* /* item */, const std::string& /* filename */) {
        return false;
    }
    virtual QWidget* getOptionPanelForSaving(Item* item) override final {
        return getOptionPanelForSaving(static_cast<ItemType*>(item));
    }
    virtual QWidget* getOptionPanelForSaving(ItemType* item) {
        return nullptr;
    }
};
 
 
class CNOID_EXPORT ItemFileIoExtenderBase : public ItemFileIO
{
    ItemFileIOPtr baseFileIO;
 
protected:
    ItemFileIoExtenderBase(const std::type_info& type, const std::string& formatId);
    
public:
    bool isAvailable() const;
    virtual bool load(Item* item, const std::string& filename) override final;
    virtual void resetOptions() override;
    virtual void storeOptions(Mapping* options) override;
    virtual bool restoreOptions(const Mapping* options) override;
    virtual QWidget* getOptionPanelForLoading() override;
    virtual void fetchOptionPanelForLoading() override;
    virtual bool save(Item* item, const std::string& filename) override final;
    virtual QWidget* getOptionPanelForSaving(Item* item) override final;
    virtual void fetchOptionPanelForSaving() override;
};
 
 
template<class ItemType, class BaseItemType = ItemType>
class ItemFileIoExtender : public ItemFileIoExtenderBase
{
public:
    ItemFileIoExtender(const std::string& formatId = "")
        : ItemFileIoExtenderBase(typeid(BaseItemType), formatId)
    { }
 
    ItemType* loadItem(
        const std::string& filename,
        Item* parentItem = nullptr, bool doAddition = true, Item* nextItem = nullptr,
        const Mapping* options = nullptr) {
        return static_cast<ItemType*>(
            ItemFileIO::loadItem(filename, parentItem, doAddition, nextItem, options));
    }
    
protected:
    virtual Item* createItem() override {
        return new ItemType;
    }
    virtual bool load(ItemType* item, const std::string& filename) {
        return ItemFileIoExtenderBase::load(item, filename);
    }
    virtual bool save(ItemType* item, const std::string& filename) {
        return ItemFileIoExtenderBase::save(item, filename);
    }
    virtual QWidget* getOptionPanelForSaving(ItemType* item) {
        return ItemFileIoExtenderBase::getOptionPanelForSaving(item);
    }
};
 
}
 
#endif