TnbCopyDataMessage.h

[詳解]

#pragma once
#include "TnbCommunication.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CCopyDataMessage : public ICommunication, CCopyImpossible
{
    DEFSUPER(ICommunication);
    _super::TProperty   m_property;         
protected:
    CVectorT<BYTE>      m_vbReceivedData;   
    HWND                m_hPartnerWnd;      
    ULONG_PTR           m_dwCookie;         
 
public:
 
    CCopyDataMessage(void) : m_property(_T("CopyDataMsg"), TNBVIW_KIND_TEMP), m_dwCookie(0), m_hPartnerWnd(NULL)
    {
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_property; 
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        return false;
    }
 
    void SetParamater(HWND hPartnerWnd, ULONG_PTR dwCookie = 0)
    {
        m_hPartnerWnd = hPartnerWnd;
        m_dwCookie = dwCookie;
    }
 
    virtual bool Open(void) 
    {
        return IsOpened();
    }
    
    virtual void Close(void) 
    {
        m_vbReceivedData.RemoveAll();
        return; 
    }
    
    virtual bool IsOpened(void) const 
    {
        return !! ::IsWindow(m_hPartnerWnd);
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( IsOpened() )
        {
            COPYDATASTRUCT data;
            data.dwData = m_dwCookie;
            data.cbData = ToDword(size);
            data.lpData = const_cast<PVOID>(P);
            LPARAM l = reinterpret_cast<LPARAM>(&data);
            DWORD_PTR result = 0;
            if ( ::SendMessageTimeout(m_hPartnerWnd, WM_COPYDATA, 0, l, SMTO_NORMAL, 1000, &result) )
            {
                return result;
            }
        }
        return INVALID_SIZE;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        size_t l = m_vbReceivedData.GetElements(size, static_cast<BYTE*>(_P));
        m_vbReceivedData.RemoveElements(0, l);
        return l;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        return m_vbReceivedData.GetSize();
    }
 
    virtual EState Check(void) const
    {
        if ( ::IsWindow(m_hPartnerWnd) )
        {
            return CONNECTING; 
        }
        return CLOSED;
    }
 
    virtual void Purge(void)
    {
        m_vbReceivedData.RemoveAll();
    }
 
    bool RelayEvent(UINT message, WPARAM wParam, LPARAM lParam, LRESULT& _result)
    {
        if ( message == WM_COPYDATA )
        {
            COPYDATASTRUCT* pData = reinterpret_cast<COPYDATASTRUCT*>(lParam);
            if ( pData->dwData == m_dwCookie )
            {
                size_t size = pData->cbData;
                PVOID P = pData->lpData;
                _result = m_vbReceivedData.AddElements(size, static_cast<const BYTE*>(P));
                return true;
            }
        }
        return false;
    }
};
 
 
 
class CCopyDataPostMessage : public CCopyDataMessage
{
    DEFSUPER(CCopyDataMessage);
    UINT        m_msg;          
    enum
    {
        COOKIE_MASK     = 0x3FFFFFFF,   
        HASBYTE_MASK    = 0xC0000000,   
        HASBYTE_SHIFT   = 30,           
        HAS1BYTE        = 0x00000000,   
        HAS2BYTE        = 0x40000000,   
        HAS3BYTE        = 0x80000000,   
        HAS4BYTE        = 0xC0000000,   
    };
public:
 
    CCopyDataPostMessage(void) : _super(), m_msg(0)
    {
    }
 
    virtual bool Open(void) 
    {
        return m_msg != 0 && IsOpened();
    }
        
    void SetMessage(UINT msg)
    {
        m_msg = msg;
    }
 
    void SetMessage(LPCTSTR msg)
    {
        m_msg = ::RegisterWindowMessage(msg);
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( ! IsOpened() )
        {
            return INVALID_SIZE;
        }
        ULONG_PTR cookie = m_dwCookie & COOKIE_MASK;
        const BYTE* B = static_cast<const BYTE*>(P);
        INDEX pos = 0;
        loop ( i, size / 4 )
        {
            const DWORD* W = reinterpret_cast<const DWORD*>(&B[pos]);
            ::PostMessage(m_hPartnerWnd, m_msg, cookie | HAS4BYTE, *W);
            pos += 4;
        }
        switch ( size & 3 )
        {
        case 0:
        default:
            break;
        case 1:
            ::PostMessage(m_hPartnerWnd, m_msg, cookie | HAS1BYTE, B[pos]);
            break;
        case 2:
            ::PostMessage(m_hPartnerWnd, m_msg, cookie | HAS2BYTE, B[pos] | (B[pos + 1] << 8));
            break;
        case 3:
            ::PostMessage(m_hPartnerWnd, m_msg, cookie | HAS3BYTE, B[pos] | (B[pos + 1] << 8) | (B[pos + 2] << 16));
            break;
        }
        return size;
    }
 
    bool RelayEvent(UINT message, WPARAM wParam, LPARAM lParam, LRESULT& _result)
    {
        if ( message == m_msg )
        {
            if ( (wParam & COOKIE_MASK) == (m_dwCookie & COOKIE_MASK) )
            {
                int len = (ToInt(wParam & HASBYTE_MASK) >> HASBYTE_SHIFT) + 1;
                if ( len >= 1 )
                {
                    m_vbReceivedData.Add(static_cast<BYTE>(lParam & 0xFF));
                }
                if ( len >= 2 )
                {
                    m_vbReceivedData.Add(static_cast<BYTE>((lParam >> 8) & 0xFF));
                }
                if ( len >= 3 )
                {
                    m_vbReceivedData.Add(static_cast<BYTE>((lParam >> 16) & 0xFF));
                }
                if ( len >= 4 )
                {
                    m_vbReceivedData.Add(static_cast<BYTE>((lParam >> 24) & 0xFF));
                }
                return true;
            }
        }
        return false;
    }
};
 
 
 
}; // TNB