---

HIOManager.h

Go to the documentation of this file.

//
// Copyright (c) 2000 by Tech Soft 3D, LLC.
// The information contained herein is confidential and proprietary to
// Tech Soft 3D, LLC., and considered a trade secret as defined under
// civil and criminal statutes.  Tech Soft 3D shall pursue its civil
// and criminal remedies in the event of unauthorized use or misappropriation
// of its trade secrets.  Use of this information by anyone other than
// authorized employees of Tech Soft 3D, LLC. is granted only under a
// written non-disclosure agreement, expressly prescribing the scope and
// manner of such use.
//
// $Header: /files/homes/master/cvs/hoops_master/hoops_mvo/source/HIOManager.h,v 1.83.2.4 2008-06-06 05:59:33 jason Exp $
//

#ifndef _H_HIO_MANAGER_H
#define _H_HIO_MANAGER_H

#ifdef H_PACK_8
#pragma pack(push)
#pragma pack(8)
#endif

#include "HTools.h"

// forwards
enum HFileOutputResult;
class HPDFOptions;
class HBaseView;
class HCamera;
class HBaseModel;
struct vlist_s;


#define HInputOpNone                    (1UL<<0)

#define HInputOpFileInputByKey          (1UL<<1)

#define HInputOpFileInputToImageKey     (1UL<<2)

#define HOutputOpNone                   (1UL<<0)

#define HOutputOpFileOutputByKey        (1UL<<1)

#define HOutputOpFileOutputFromImageKey (1UL<<2)


#define HIORegisterInputType(type,input_object) do {HIOManager::GetCurrentHIOManager()->RegisterInputHandler(type, input_object); }while(0);



#define HIORegisterOutputType(type,output_object) do { HIOManager::GetCurrentHIOManager()->RegisterOutputHandler(type, output_object); }while(0); 




class MVO_API HIONoticeCallback
{
public:
    virtual ~HIONoticeCallback() {;};
    virtual void Notice(const char * notice) =0;
};

class MVO_API HIOPercentNoticeCallback
{
public:
    virtual ~HIOPercentNoticeCallback() {;};
    virtual void Notice(float notice) =0;
};



typedef void * (*HIO_CREATE_FREE_FUNCTION)(void *);

typedef void (*HIO_FREE_CONNECTOR_FUNCTION)(void *);

class MVO_API HIOConnector
{
public:

    /*Constructs an HIOConnector object.*/
    HIOConnector();
    virtual ~HIOConnector();

    virtual HC_KEY GetHoopsEntity(void * pKernelEntity);

    virtual void * GetKernelEntity(HC_KEY key);

    virtual bool GetHoopsEntities(void * pKernelEntity, vlist_s *ret_HoopsKeysList);

    virtual bool GetKernelEntities(HC_KEY key, vlist_s *ret_KernelEntitiesList);

    virtual void AddConnection(HC_KEY key, void* pKernelEntity);


    virtual void OptimizeTree(const char * segname, const char * option_string);

protected:

    struct vhash_s *mhash_Hoops2Kernel;

    struct vhash_s *mhash_Kernel2Hoops;

};

enum HInputHandlerStyle {
    HInputHandlerStyleModel, 
    HInputHandlerStyleImage  
};

class MVO_API HInputHandlerOptions 
{
public:

    HInputHandlerOptions() {
        m_pHBaseView=0;
        m_pImageName=0;
        m_pImageFormat=0;
        m_pConnector=0;
        m_pExtendedData=0;
        m_bLocal = false;

        // DWG import options (try and move them somewhere else)
        m_bInputViaHSF = false;
        m_Deviation = 10.0;
        m_bImportMetadata = false;
        m_bMergeEntityShells = true;
        m_bImportWireframeForBrep = false;
        m_numIsolines = 0;
        m_listRegAppNames = 0;
        m_listEntityType=0;
        m_bForceReimport = false;
        m_listDWGLayouts = 0;
    };

    HInputHandlerOptions(HInputHandlerOptions const *o) {
        m_pHBaseView = o->m_pHBaseView;
        m_pImageName = o->m_pImageName;
        m_pImageFormat = o->m_pImageFormat;
        m_pConnector = o->m_pConnector;
        m_pExtendedData = o->m_pExtendedData;
        m_bLocal = o->m_bLocal;
        m_bInputViaHSF = o->m_bInputViaHSF;
        m_Deviation = o->m_Deviation;
        m_bImportMetadata = o->m_bImportMetadata;
        m_bMergeEntityShells = o->m_bMergeEntityShells;
        m_bImportWireframeForBrep = o->m_bImportWireframeForBrep;
        m_numIsolines = o->m_numIsolines;
        m_listRegAppNames = o->m_listRegAppNames;
        m_listEntityType=o->m_listEntityType;   
        m_bForceReimport = o->m_bForceReimport;
        m_listDWGLayouts = o->m_listDWGLayouts;
    };

    HInputHandlerOptions(const HInputHandlerOptions &o) {
        m_pHBaseView = o.m_pHBaseView;
        m_pImageName = o.m_pImageName;
        m_pImageFormat = o.m_pImageFormat;
        m_pConnector = o.m_pConnector;
        m_pExtendedData = o.m_pExtendedData;
        m_bLocal = o.m_bLocal;
        m_bInputViaHSF = o.m_bInputViaHSF;
        m_Deviation = o.m_Deviation;
        m_bImportMetadata = o.m_bImportMetadata;
        m_bMergeEntityShells = o.m_bMergeEntityShells;
        m_bImportWireframeForBrep = o.m_bImportWireframeForBrep;
        m_numIsolines = o.m_numIsolines;
        m_listRegAppNames = o.m_listRegAppNames;
        m_listEntityType=o.m_listEntityType;
        m_bForceReimport = o.m_bForceReimport;
        m_listDWGLayouts = o.m_listDWGLayouts;
    };

    virtual ~HInputHandlerOptions() {;};

    HBaseView * m_pHBaseView;

    const char * m_pImageName;

    const char * m_pImageFormat;

    bool m_bLocal;

    HIOConnector * m_pConnector;

    void * m_pExtendedData;

    bool m_bInputViaHSF;

    double m_Deviation;

    bool m_bImportMetadata;

    struct vlist_s * m_listRegAppNames;

    struct vlist_s * m_listEntityType;


    bool m_bMergeEntityShells;

    bool m_bImportWireframeForBrep;

    double m_numIsolines;

    bool m_bForceReimport;

    struct vlist_s * m_listDWGLayouts;
    
};




class MVO_API HInputHandler 
{

public:
    HInputHandler();
    virtual ~HInputHandler();

    unsigned long GetInputOps() {return m_InputOps;};

    virtual void RegisterInputHandlerTypes() = 0;

    virtual HInputHandlerStyle GetInputStyle() = 0;

    virtual HFileInputResult FileInputByKey(const char * filename, HC_KEY key, HInputHandlerOptions * options){return InputNotHandled;};

    virtual HFileInputResult FileInputByKey(const unsigned short * filename, HC_KEY key, HInputHandlerOptions * options);

    virtual HFileInputResult FileInputToImageKey(const char * filename, HC_KEY  *image_key, HC_KEY segment_key, HInputHandlerOptions * options){return InputNotHandled;};


    virtual HFileInputResult FileInputToImageKey(const unsigned short * filename, HC_KEY  *image_key, HC_KEY segment_key, HInputHandlerOptions * options);

    virtual const char * GetInputTypesString() = 0;

    const char * GetInputProgress();

    float GetInputPercentProgress();

    const char * GetInputInformation();

    HIONoticeCallback * SetInputProgressNoticeCallback(HIONoticeCallback *notice_callback);
    
    
    HIOPercentNoticeCallback * SetInputPercentProgressNoticeCallback(HIOPercentNoticeCallback *percent_notice_callback);
    
    HIONoticeCallback * SetInputInformationNoticeCallback(HIONoticeCallback *notice_callback);

    void ReportInputProgress(const char * progress);

    void ReportInputPercentProgress(float percent_progress);

    void ReportInputInformation(const char * information);

protected:

    void SetStartingInput(const char *filename = 0);

    void SetFinishedInput();

    void SetInputOps(unsigned long ops) {m_InputOps=ops;};

    unsigned long m_InputOps;

private:
    char *m_progress;
    float m_percent_progress;
    char *m_information;
    struct vlist_s *m_information_list;
    HIONoticeCallback *m_progress_callback;
    HIONoticeCallback *m_information_callback;
    HIOPercentNoticeCallback *m_percent_progress_callback;
};

enum HOutputHandlerStyle 
{
    HOutputHandlerStyleModel, 
    HOutputHandlerStyleImage, 
    HOutputHandlerStyleHardcopy, 
    HOutputHandlerStyleHTML, 
    HOutputHandlerStyleDontCare
};

class MVO_API HOutputHandlerOptions 
{
public:
    HOutputHandlerOptions() {
        m_Key = INVALID_KEY;
        m_pHBaseView = 0;
        m_pHBaseModel = 0;
        m_pCamera = 0;
        m_pExtendedData = 0;
        m_pHSRAOptions = 0;
        m_pWindowColor = 0;
        m_Window_Width = 0;
        m_Window_Height = 0;
        m_Paper_Width = 8.5;
        m_Paper_Height = 11;
        m_Image_Dpi = 100;
        m_Paper_Dpi = 300;
        m_Version = 0;
        m_bUseWindowColor = false;
        m_ForceGrayscale = false;
        m_bFastPrint = false;
        m_bConserveMemory = false;
        m_bUseSubscreen = true;
        m_bWindowFrame = false;
        m_b3dOutput = false;
        m_bAscii = false;
        m_bWriteAnimations = false;
    };
    
    HOutputHandlerOptions(HOutputHandlerOptions const *o) {
         Init(o);
    };

    HOutputHandlerOptions(const HOutputHandlerOptions &o) {
        Init(&o);
    };


    virtual ~HOutputHandlerOptions() {;};

    void Init(HOutputHandlerOptions const *o)
    {   
        m_pHBaseView = o->m_pHBaseView;
        m_pHBaseModel = o->m_pHBaseModel;
        m_pCamera = o->m_pCamera;
        m_Key = INVALID_KEY;
        m_pHSRAOptions = o->m_pHSRAOptions;
        m_bUseWindowColor = o->m_bUseWindowColor;
        m_pWindowColor = o->m_pWindowColor;
        m_Window_Width = o->m_Window_Width;
        m_Window_Height = o->m_Window_Height;
        m_Paper_Width = o->m_Paper_Width;
        m_Paper_Height = o->m_Paper_Height;
        m_ForceGrayscale = o->m_ForceGrayscale;
        m_bFastPrint = o->m_bFastPrint;
        m_bConserveMemory = o->m_bConserveMemory;
        m_Image_Dpi = o->m_Image_Dpi;
        m_Paper_Dpi = o->m_Paper_Dpi;
        m_pExtendedData = o->m_pExtendedData;
        m_Version = o->m_Version;
        m_bUseSubscreen = o->m_bUseSubscreen;
        m_bWindowFrame = o->m_bWindowFrame;
        m_b3dOutput = o->m_b3dOutput;
        m_bWriteAnimations = o->m_bWriteAnimations;
    }

    HBaseView * m_pHBaseView;
    HBaseView * const View() const {return m_pHBaseView;};
    void View(HBaseView * const v) {m_pHBaseView = v;};

    HBaseModel * m_pHBaseModel;
    HBaseModel * const Model() const {return m_pHBaseModel;};
    void Model(HBaseModel * const m) {m_pHBaseModel = m;};

    HCamera * m_pCamera;
    HCamera * const Camera() const {return m_pCamera;};
    void Camera(HCamera * const c) {m_pCamera = c;};

    HC_KEY m_Key;
    HC_KEY const Key() const {return m_Key;};
    void Key(HC_KEY const k) {m_Key = k;};

    char const * m_pHSRAOptions;
    char const * const HSRAOptions() const {return m_pHSRAOptions;};
    void HSRAOptions(char const * const tf) {m_pHSRAOptions = tf;};

    HPoint const * m_pWindowColor;
    HPoint const * const WindowColor() const {return m_pWindowColor;};
    void WindowColor(HPoint const * const tf) {m_pWindowColor = tf;};

    bool m_bUseWindowColor;
    bool const UseWindowColor() const {return m_bUseWindowColor;};
    void UseWindowColor(bool const tf) {m_bUseWindowColor = tf;};

    float m_Window_Width;
    float const WindowWidth() const {return m_Window_Width;};
    void WindowWidth(float const f) {m_Window_Width = f;};

    float m_Window_Height;
    float const WindowHeight() const {return m_Window_Height;};
    void WindowHeight(float const f) {m_Window_Height = f;};

    float m_Paper_Width;
    float const PaperWidth() const {return m_Paper_Width;};
    void PaperWidth(float const f) {m_Paper_Width = f;};

    float m_Paper_Height;
    float const PaperHeight() const {return m_Paper_Height;};
    void PaperHeight(float const f) {m_Paper_Height = f;};

    bool m_ForceGrayscale;
    bool const ForceGrayscale() const {return m_ForceGrayscale;};
    void ForceGrayscale(bool const tf) {m_ForceGrayscale = tf;};

    bool m_bFastPrint;
    bool const FastPrint() const {return m_bFastPrint;};
    void FastPrint(bool const tf) {m_bFastPrint = tf;};

    bool m_bConserveMemory;
    bool const ConserveMemory() const {return m_bConserveMemory;};
    void ConserveMemory(bool const tf) {m_bConserveMemory = tf;};

    bool m_bWriteAnimations;
    bool const WriteAnimations() const {return m_bWriteAnimations;};
    void WriteAnimations(bool const tf) {m_bWriteAnimations = tf;};

    bool m_bWindowFrame;
    bool const WindowFrame() const {return m_bWindowFrame;};
    void WindowFrame(bool const tf) {m_bWindowFrame = tf;};

    bool m_bUseSubscreen;
    bool const UseSubscreen() const {return m_bUseSubscreen;};
    void UseSubscreen(bool const tf) {m_bUseSubscreen = tf;};

    int m_Image_Dpi;
    int const ImageDpi() const {return m_Image_Dpi;};
    void ImageDpi(int const dpi) {m_Image_Dpi = dpi;};

    int m_Paper_Dpi;
    int const PaperDpi() const {return m_Paper_Dpi;};
    void PaperDpi(int const dpi) {m_Paper_Dpi = dpi;};

    void * m_pExtendedData;
    void * const ExtendedData() const {return m_pExtendedData;};
    void ExtendedData(void * const vp) {m_pExtendedData = vp;};
    void ExtendedData(HPDFOptions * const vp) {m_pExtendedData = (void*)vp;};


    int m_Version;
    int const Version() const {return m_Version;};
    void Version(int const v) {m_Version = v;};

    int m_OutputType;
    int const OutputType() const {return m_OutputType;};
    void OutputType(int const ot) {m_OutputType = ot;};

    bool m_b3dOutput;
    bool const Output3d() const {return m_b3dOutput;};
    void Output3d(bool const tf) {m_b3dOutput = tf;};

    bool m_bAscii;
    bool const Ascii() const {return m_bAscii;};
    void Ascii(bool const tf) {m_bAscii = tf;};
};



class MVO_API HOutputHandler 
{

public:
    HOutputHandler();
    virtual ~HOutputHandler();

    unsigned long GetOutputOps() {return m_OutputOps;};
    
    virtual void RegisterOutputHandlerTypes() = 0;


    virtual HFileOutputResult FileOutputByKey(const char * filename, HC_KEY key, HOutputHandlerOptions * options){return OutputNotHandled;};

    virtual HFileOutputResult FileOutputByKey(const unsigned short * filename, HC_KEY key, HOutputHandlerOptions * options){return OutputNotHandled;};


    virtual HFileOutputResult FileOutputFromImageKey(const char * filename, HC_KEY image_key, HOutputHandlerOptions * options){return OutputNotHandled;};

    virtual const char * GetOutputTypesString() = 0;

    virtual HOutputHandlerStyle GetOutputStyle() = 0;
    
    virtual const char * GetOutputDefaultHSRA() {return 0;};

    const char * GetOutputProgress();

    float GetOutputPercentProgress();

    const char * GetOutputInformation();

    HIONoticeCallback * SetOutputProgressNoticeCallback(HIONoticeCallback *notice_callback);

    
    HIOPercentNoticeCallback * SetOutputPercentProgressNoticeCallback(HIOPercentNoticeCallback *percent_notice_callback);
    
    HIONoticeCallback * SetOutputInformationNoticeCallback(HIONoticeCallback *notice_callback);

    void ReportOutputProgress(const char * progress);

    void ReportOutputPercentProgress(float percent_progress);

    void ReportOutputInformation(const char * information);

protected:

    void SetStartingOutput();

    void SetFinishedOutput();

    void SetOutputOps(unsigned long ops) {m_OutputOps=ops;};
    unsigned long m_OutputOps;

private:
    char *m_progress;
    float m_percent_progress;
    char *m_information;
    struct vlist_s *m_information_list;
    HIONoticeCallback *m_progress_callback;
    HIOPercentNoticeCallback *m_percent_progress_callback;
    HIONoticeCallback *m_information_callback;
};

class MVO_API HIOManager
{

public:

    HIOManager();
    virtual ~HIOManager();
    
    virtual HInputHandler * RegisterInputHandler(const char * file_type, HInputHandler * handler);

    virtual HOutputHandler * RegisterOutputHandler(const char * file_type, HOutputHandler * handler);

    virtual HIOConnector * RegisterConnector(const char * file_type, HIO_CREATE_FREE_FUNCTION Create, HIO_FREE_CONNECTOR_FUNCTION Free);

    virtual HInputHandler * GetInputHandler(const char * file_type);

    virtual HOutputHandler * GetOutputHandler(const char * file_type);

    virtual void RegisterHandlers();

    virtual const char * GetInputHandlerTypes();

    virtual const char * GetOutputHandlerTypes();


    virtual HIOConnector * CreateConnector(const char * file_type);

    virtual void FreeConnector(HIOConnector * old_connector);


    static HIOManager *GetCurrentHIOManager();

    static void GetFileOutputResultString(HFileOutputResult result, char *result_str);

protected:

    struct vhash_s * input_handlers;

    struct vhash_s * output_handlers;

    struct vhash_s * connector_procs;

    struct vlist_s * owned_input_handlers;

    struct vlist_s * owned_output_handlers;

    struct vlist_s * loaded_input_handlers;

    struct vlist_s * loaded_output_handlers;

    struct vhash_s * created_connectors;

    char * m_input_types;
    int m_input_types_allocated;

    char * m_output_types;
    int m_output_types_allocated;
};




#ifdef H_PACK_8
#pragma pack(pop)
#endif

#endif