core/register.h

/*
 *  Copyright (c) 2004    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_CORE_REGISTER_H__
#define __INCLUDED_SCOPIRA_CORE_REGISTER_H__

#include <scopira/tool/objflowloader.h>

namespace scopira
{
  namespace core
  {
    enum
    {
      vg_primary =      0x0001,       // not used, but i might sometime
      vg_noui_c =       0x0002,       // doesnt actually have a UI component (and doesnt decent from coreui::widget, etc)
      vg_windowui_c =   0x0004,       // has a gui, and always wants to be in its own window (having this and vg_noui_c)

      vg_needs_project_c = 0x0100,    // a view that requires the model to have a project and be clicked from the project tree manager
      vg_needs_copyfunc_c = 0x0200,   // a view that requires the model have a registered copy ctor/func

      vg_show_c =       0x00FF,       // lower 16 are shown by default
      vg_hide_c =       0xFF00,       // default that are hidden (just to be complete)
    };

    // another mapping of the above
    enum
    {
      no_uimode_c = vg_noui_c,
      default_uimode_c = 0,
      windowonly_uimode_c = vg_windowui_c,
    };

    class interface_model_type { };
    class copyable_model_type { };

    typedef scopira::tool::object* (*copyfunc_t)(const scopira::tool::object*);
    template <class T> scopira::tool::object* objcopyfunc_g(const scopira::tool::object *srco) { return new T(*dynamic_cast<const T*>(srco)); }

    class mi_set;

    template <class T> class register_flow;
    template <class T> class register_object;
    template <class T> class register_model;
    template <class T> class register_view;
    //class register_task;

    SCOPIRA_EXPORT void flow_reg_imp(const std::type_info& id, const char * name, scopira::tool::objflowloader::loadfunc_t loader);
    SCOPIRA_EXPORT void link_object_parent_imp(const std::type_info &id, const char *parent_name);
    SCOPIRA_EXPORT void link_object_parent_imp(const std::type_info &id, const char **parents);
    SCOPIRA_EXPORT void link_object_copyfunc(const std::type_info &id, copyfunc_t cf);
    SCOPIRA_EXPORT void link_model_imp(const std::type_info &id, bool linktomodeltype);
    SCOPIRA_EXPORT void link_view_imp(const std::type_info &id, const char *model_type, const char *menu_name, int vgmask);
    class objecttype;
    SCOPIRA_EXPORT void build_objecttype_tree(scopira::tool::count_ptr<scopira::core::objecttype> &out);

    extern SCOPIRA_EXPORT const char *object_type_c;
    extern SCOPIRA_EXPORT const char *model_type_c;
    extern SCOPIRA_EXPORT const char *project_type_c;
    extern SCOPIRA_EXPORT const char *view_type_c;
  }
}

// Lots of C-array stuff for efficincy when making static objects
// all resolves to std::strings for storage, though

class scopira::core::mi_set
{
  public:
    const char * pm_parents[4];

  public:
    // ctors

    mi_set(const char *parent0)
      { pm_parents[0] = parent0; pm_parents[1] = 0; }
    mi_set(const char *parent0, const char *parent1)
      { pm_parents[0] = parent0; pm_parents[1] = parent1; pm_parents[2] = 0; }
    mi_set(const char *parent0, const char *parent1, const char *parent2)
      { pm_parents[0] = parent0; pm_parents[1] = parent1; pm_parents[2] = parent2; pm_parents[3] = 0; }
};

template <class T>
class scopira::core::register_flow
{
  public:
    register_flow(const char *fullname) {
      scopira::core::flow_reg_imp(typeid(T), (fullname), scopira::tool::objloadfunc_g<T>);
    }
    register_flow(const char *fullname, int dummy) {
      scopira::core::flow_reg_imp(typeid(T), (fullname), 0);
    }
};

template <class T>
class scopira::core::register_object : public scopira::core::register_flow<T>
{
  private:
    typedef scopira::core::register_flow<T> parent_type;
  public:
    register_object(const char *fullname, const char *parent_name = 0)
      : parent_type(fullname)
      { link_object_parent_imp(typeid(T), parent_name); }
    register_object(const char *fullname, mi_set s)
      : parent_type(fullname)
      { link_object_parent_imp(typeid(T), s.pm_parents); }
    register_object(const char *fullname, const char *parent_name, int dummy)
      : parent_type(fullname, dummy)
      { link_object_parent_imp(typeid(T), parent_name); }

    // a pure conat char ** one can be made too, if need be
};

template <class T>
class scopira::core::register_model : public scopira::core::register_flow<T>
{
  private:
    typedef scopira::core::register_flow<T> parent_type;
  public:
    register_model(const char *fullname, const char *parent_name = 0)
      : parent_type(fullname)
      { link_model_imp(typeid(T), !parent_name); link_object_parent_imp(typeid(T), parent_name); }
    register_model(const char *fullname, const char *parent_name, copyable_model_type dummyinstance)
      : parent_type(fullname)
      { link_model_imp(typeid(T), !parent_name); link_object_parent_imp(typeid(T), parent_name);
        link_object_copyfunc(typeid(T), objcopyfunc_g<T>); }
    register_model(const char *fullname, mi_set s)
      : parent_type(fullname)
      { link_model_imp(typeid(T), false); link_object_parent_imp(typeid(T), s.pm_parents); }
    register_model(const char *fullname, const char *parent_name, interface_model_type dummyinstance)
      : parent_type(fullname, 1)
      { link_model_imp(typeid(T), !parent_name); link_object_parent_imp(typeid(T), parent_name); }

    // a pure const char ** one can be made too, if need be
};

template <class T>
class scopira::core::register_view : public scopira::core::register_flow<T>
{
  private:
    typedef scopira::core::register_flow<T> parent_type;
  public:

    register_view(const char *fullname, const char *model_type, const char *menu_name, int vgmask = default_uimode_c)
      : parent_type(fullname)
      { link_view_imp(typeid(T), model_type, menu_name, vgmask); }
};

#endif