DynamicExchangeWindow.h

#if !defined(DYNAMICEXCHANGEWINDOW_H)
#define DYNAMICEXCHANGEWINDOW_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "DynamicExchangeCommon.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
DLL_3DFUNCTION bool SendInfoToWnd(CXWinWnd *pSrCXWnd, CXWinWnd *pDstWnd, unsigned int action, const void *data, fileuint size, bool activate);
DLL_3DFUNCTION bool SendFileToWnd(HWND hSrCXWnd, CCustomMemFile& file, const CXString& wndName, unsigned int action, bool activate, HWND hWnd = NULL);
 
// define MOOTOOLS_NO_DYNSERVER_CLASS if you don't need a complete support from a client application
class DLL_3DFUNCTION CDynExchangeWindow : public CXWinWnd
{
public:
    CDynExchangeWindow();
    virtual ~CDynExchangeWindow();
    
    bool Create(const CXString& clientClassName, const CXString& serverClassName); // Creates the windows handle
 
    bool SendMessageData(unsigned int message, const unsigned char *data = NULL, fileuint dataSize = 0, const CCustomData *additionalData = NULL, HWND specificHWnd = NULL); // Send any kind of data. data and/or additionalData can be NULL.
    
    // send information
    // additionalCustomData can be used to define a specific value between the caller and the client.
    // For example you can pass a DYNAMICDATA_3DSOFTWARE that will allow to filter only data from a specific software.
#ifndef MOOTOOLS_NO_DYN3D
    bool SendScene(C3DScene *scene, bool deleteIt, const CCustomData *additionalCustomData = NULL, HWND specificHWnd = NULL); // Send a scene to an external application. If the scene is temporary, using deleteIt = true, is a good idea, so it is deleted before sending it to the external application (this limit memory consumption)
    bool SendNode(C3DSceneNode *node, bool skipGeom = false, const CCustomData *additionalCustomData = NULL); // If skipGeom is true, then only the node (without the geometry) is sent.
    bool SendNodes(C3DScene *scene, const C3DNodeArray& nodes, const CBitArray *skipGeoms = NULL, const CCustomData *additionalCustomData = NULL);
#endif
 
#if !defined(MOOTOOLS_NO_DYNBITMAP) && !defined(MOOTOOLS_NO_BITMAP)
    bool SendBitmap(Bitmap *bitmap, bool deleteIt, const CCustomData *additionalCustomData = NULL, HWND specificHWnd = NULL);
#endif
 
    // Receive information
#ifndef MOOTOOLS_NO_DYNBITMAP
    virtual void ReceiveBitmap(const CXString& filename, CBitmap *bitmap, bool asAlpha) {};
#endif
 
#ifndef MOOTOOLS_NO_DYN3D
    virtual bool ReceiveScene(C3DScene *scene, const CCustomData *additionalData = NULL) const { return false; } // Receive a scene from software. The receiver is owner of the scene if it return true and then should delete it if needed. If the receiver return false, it can't handle the scene and the caller will delete it
    virtual bool ReceiveNode(C3DSceneNode *node, const CCustomData *additionalData = NULL) const { return false; } // Receive a node
    virtual bool ReceiveNodes(C3DNodeArray& nodes, const CCustomData *additionalData = NULL) const { return false; } // Receive several nodes 
#endif
 
    virtual bool ReceiveMessageData(unsigned int message, const unsigned char *data, fileuint dataSize, const CCustomData *additionalData = NULL) { return false; } // Received private data. The receiver is the owner of the data, it return true. It then should delete the data using xDeallocateArray. If the method return false, then the data is automatically freed
 
    protected:
    CXString clientClass; // The class of the external application
    CXString serverClass; // The class of our application (ie 3DBrowser)
 
#ifndef MOOTOOLS_NO_DYN3D
    C3DScene *ReceiveScene(const unsigned char *data, unsigned int dataSize, const CCustomData& additionalData);
#endif
 
    virtual LPCTSTR GetClass() = 0;
    virtual LPCTSTR GetDestClass() = 0;
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    BOOL OnCopyData(CXWinWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
    void PumpMessages();
};
 
class DLL_3DFUNCTION CDynServerWindow : public CDynExchangeWindow
{
// Construction
public:
    CDynServerWindow();
    virtual ~CDynServerWindow();
 
protected:
    LPCTSTR GetClass() { return serverClass; }
    LPCTSTR GetDestClass() { return clientClass; }
    BOOL OnCopyData(CXWinWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
 
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
    DECLARE_MESSAGE_MAP()
#endif
};
 
class DLL_3DFUNCTION CDynClientWindow : public CDynExchangeWindow
{
// Construction
public:
    CDynClientWindow();
    virtual ~CDynClientWindow();
 
    #ifndef MOOTOOLS_NO_DYN3D
    #ifdef MOOTOOLS_MFC_PRODUCT_BUILD
    protected:
    unsigned int lock;
 
    public:
    virtual void BeginSceneScan() {};
    virtual void EndSceneScan() {};
    virtual void ReceiveScene(const CXString& filename, C3DScene *scene, bool updateMode, bool silentMode) {};
    virtual C3DScene *ReadScene(const CXString& filename, bool updateMode, bool silentMode) { return NULL; };
    #endif
    #endif
 
// Overrides
    protected:
    LPCTSTR GetClass() { return clientClass; }
    LPCTSTR GetDestClass() { return serverClass; }
    BOOL OnCopyData(CXWinWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
 
    // Generated message map functions
protected:
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
    DECLARE_MESSAGE_MAP()
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(DYNAMICEXCHANGEWINDOW_H)