TnbClipboard.h

[詳解]

#pragma once
#ifdef _TnbCLIPBOARD_OtherType_ENABLE
 #include "TnbDntStr.h"
 #include "TnbMap.h"
#else
 #include "TnbStr.h"
#endif
#include "TnbBitmapHandle.h"
#include <shlobj.h>
#include <wingdi.h>
#ifndef _WIN32_WCE
 #pragma comment(lib,"gdi32.lib")
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CClipboard : CCopyImpossible
{
public:
 
    explicit CClipboard(HWND hWnd = NULL, DWORD dwOpenTimeout = 500, bool boHasErrBox = false)
        : m_hWnd(hWnd), m_dwOpenTimeout(dwOpenTimeout), m_boHasErrBox(boHasErrBox)
    {
    }
 
    void SetHandle(HWND hWnd)
    {
        m_hWnd = hWnd;
    }
 
    bool Empty(void)
    {
        bool boRc = false;
        if ( m_Open(true) )
        {
            m_Close();
            boRc = true;
        }
        return boRc;
    }
 
    bool IsAvailable(UINT uFormat = 0) const
    {
        bool boRc = false;
        if ( uFormat == 0 )
        {
            uFormat = CBFMT_TEXT;
        }
        if ( m_Open() )
        {
            boRc = !! ::IsClipboardFormatAvailable(uFormat);
            m_Close();
        }
        return boRc;
    }
 
    static CStr GetFormatName(UINT uFormat)
    {
        CStr str;
        int r = ::GetClipboardFormatName(uFormat, str.GetBuffer(1024), 1024);
        _GetLastError("GetClipboardFormatName");
        str.ReleaseBuffer();
        if ( r == 0 )
        {
            str.Empty();
        }
        return str;
    }
 
    static UINT RegisterUserDataType(LPCTSTR lpszDataTypeName)
    {
        return ::RegisterClipboardFormat(lpszDataTypeName);
    }
 
    CStr GetString(void) const
    {
        CStr strRc;
        if ( m_Open() )
        {
            if ( ::IsClipboardFormatAvailable(CBFMT_TEXT) )
            {
                HANDLE hMem = ::GetClipboardData(CBFMT_TEXT);
                if ( hMem != NULL )
                {
                    strRc = static_cast<LPCTSTR>(GlobalLock(hMem));
                    GlobalUnlock(hMem);
                }
            }
            m_Close();
        }
        return strRc;
    }
 
    bool SetString(LPCTSTR lpszText, bool isAdd = false)
    {
        if ( ! m_Open(! isAdd) )
        {
            return false;
        }
        size_t iStrLen = STRLIB::GetLen(lpszText);
        HGLOBAL hMem = m_AllocAndCopy((iStrLen + 1) * sizeof(TCHAR), lpszText);
        bool boRc = m_SetData(CBFMT_TEXT, hMem);
        m_Close();
        return boRc;
    }
 
    bool GetUserData(CWorkMem& _data, UINT dataTypeId) const
    {
        bool r = false;
        if ( m_Open() )
        {
            if ( ::IsClipboardFormatAvailable(dataTypeId) )
            {
                HGLOBAL h = ::GetClipboardData(dataTypeId);
                size_t len = ::GlobalSize(h);
                _data.Reset(len, static_cast<BYTE*>(GlobalLock(h)));
                r = true;
                GlobalUnlock(h);
            }
            m_Close();
        }
        return r;
    }
    
    bool SetUserData(UINT dataTypeId, size_t dataSize, LPCVOID pData, bool isAdd = false)
    {
        if ( ! m_Open(! isAdd) )
        {
            return false;
        }
        HGLOBAL h = m_AllocAndCopy(dataSize, pData);
        bool r = m_SetData(dataTypeId, h);
        m_Close();
        return r;
    }
 
    #ifndef _WIN32_WCE
 
    HBITMAP GetBitmap(void) const
    {
        HBITMAP rc = NULL;
        if ( m_Open() )
        {
            if ( ::IsClipboardFormatAvailable(CF_BITMAP) )
            {
                HBITMAP hBmp = static_cast<HBITMAP>(::GetClipboardData(CF_BITMAP));
                if ( hBmp != NULL )
                {
                    rc = static_cast<HBITMAP>(::CopyImage(hBmp, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION));
                }
            }
            m_Close();
        }
        return rc;
    }
 
    bool SetBitmap(HBITMAP bmp, bool isAdd = false)
    {
        if ( ! m_Open(! isAdd) )
        {
            return false;
        }
        BITMAPINFOHEADER bmi;
        RGBQUAD* pRgb = NULL;
        HBITMAP hBmp = CBitmapHandle::Create32bitDibSection(bmp, pRgb, &bmi);
        if ( hBmp == NULL )
        {
            return false;
        }
        HGLOBAL h = ::GlobalAlloc(GHND, sizeof(bmi) + bmi.biWidth * bmi.biHeight * sizeof(RGBQUAD));
        BYTE* B = static_cast<BYTE*>(::GlobalLock(h));
        MemCopy(B, &bmi, sizeof(bmi));
        MemCopy(&B[sizeof(bmi)], pRgb, bmi.biWidth * bmi.biHeight * sizeof(RGBQUAD));
        ::GlobalUnlock(h);
        bool boRc = m_SetData(CF_DIB, h);
        _DeleteObject(hBmp);
        m_Close();
        return boRc;
    }
 
    #endif // _WIN32_WCE
 
    #ifdef _TnbCLIPBOARD_OtherType_ENABLE
 
    #ifndef _WIN32_WCE
 
    bool GetDropInfo(CStrVector& _vstrFiles, DWORD& _dwEffect) const
    {
        bool boRc = false;
        _vstrFiles.RemoveAll();
        _dwEffect = 0;
        if ( m_Open() )
        {
            if ( ::IsClipboardFormatAvailable(CF_HDROP) )
            {
                HDROP hDrop = static_cast<HDROP>(::GetClipboardData(CF_HDROP));
                TCHAR atcBuf[MAX_PATH];
                int iCount = ToInt(::DragQueryFile(hDrop, 0xFFFFFFFF, NULL, NULL));
                for ( int i = 0; i < iCount; i++ )
                {
                    ::DragQueryFile(hDrop, i, atcBuf, MAX_PATH);
                    _vstrFiles.Add(atcBuf);
                }
                //
                UINT uFmt = ::RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT);
                HANDLE hDropEffect = ::GetClipboardData(uFmt);
                if ( hDropEffect != NULL )
                {
                    _dwEffect = *static_cast<DWORD*>(::GlobalLock(hDropEffect));
                    ::GlobalUnlock(hDropEffect);
                    boRc = true;
                }
            }
            m_Close();
        }
        return boRc;
    }
 
    bool SetDropInfo(const CStrVector& vstrFiles, DWORD dwEffect = DROPEFFECT_COPY)
    {
        if ( ! m_Open(true) )
        {
            return false;
        }
        bool boRc = false;
        //Double Null Term Str 作成
        CDoubleNullTerminateStr dnt;
        dnt.Set(vstrFiles);
        //CF_HDROPを作成
        DROPFILES dfs = { sizeof(dfs) };
        #ifdef _UNICODE
            dfs.fWide = 1;
        #endif
        size_t size = dnt.GetSize() * sizeof(TCHAR);
        HGLOBAL hDrop = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(DROPFILES) + size);
        BYTE* B = static_cast<BYTE*>(::GlobalLock(hDrop));
        MemCopy(B, reinterpret_cast<const BYTE*>(&dfs), sizeof(DROPFILES));
        B += sizeof(DROPFILES);
        MemCopy(B, reinterpret_cast<const BYTE*>(LPCTSTR(dnt)), size);
        ::GlobalUnlock(hDrop);
        //Preferred DropEffectを作成
        HGLOBAL hDropEffect = m_AllocAndCopy(sizeof(DWORD), &dwEffect);
        //クリップボードにデータをセット
        UINT uFmt = ::RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT);
        if ( ::SetClipboardData(CF_HDROP, hDrop) == NULL )
        {
            ::GlobalFree(hDropEffect);
            ::GlobalFree(hDrop);
        }
        else if ( ::SetClipboardData(uFmt, hDropEffect) == NULL )
        {
            ::GlobalFree(hDropEffect);
        }
        else
        {
            boRc = true;
        }
        m_Close();
        return boRc;
    }
 
    #endif // _WIN32_WCE
 
    typedef CMapT< UINT, CVectorT<BYTE> > CDataMap;
 
    bool GetAll(CDataMap& _data, bool boIsWithMetafile = false, bool boIsWithRegData = false) const
    {
        bool boRc = false;
        _data.RemoveAll();
        if ( ! m_Open() )
        {
            return false;
        }
        UINT uFormat = 0;
        while ( true )
        {
            UINT r = ::EnumClipboardFormats(uFormat);
            if ( r == 0 )
            {
                DWORD dwError = _GetLastError("EnumClipboardFormats");
                if ( dwError == NO_ERROR )
                {
                    boRc = true; 
                }
                else
                {
                    _data.RemoveAll(); 
                }
                break;
            }
            //
            bool boIsValid = false;
            switch ( r )
            {
            case CBFMT_TEXT:    //CF_TEXT CF_UNICODETEXT CF_OEMTEXT と同期
            case CF_DIB:        //CF_BITMAP CF_PALETTE CF_DIBV5 と同期
                boIsValid = true;
                break;
#ifndef _WIN32_WCE
            case CF_ENHMETAFILE:    //CF_METAFILEPICT と同期
                boIsValid = boIsWithMetafile;
                break;
#endif
            default:
                if ( boIsWithRegData )
                {
                    boIsValid = (r >= 0x8000);
                }
                break;
            }
            //
            if ( boIsValid )
            {
                CVectorT<BYTE> v;
                HANDLE hMem = ::GetClipboardData(r);
#ifndef _WIN32_WCE
                if ( r == CF_ENHMETAFILE )
                {
                    HENHMETAFILE h = (HENHMETAFILE)hMem;
                    UINT l = ::GetEnhMetaFileBits(h, 0, NULL);
                    ::GetEnhMetaFileBits(h, l, v.GetBuffer(l));
                    v.ReleaseBuffer();
                }
                else
#endif
                {
                    v.SetElements(static_cast<size_t>(::GlobalSize(hMem)), static_cast<BYTE*>(GlobalLock(hMem)));
                    GlobalUnlock(hMem);
                }
                _data[r] = v;
                TRACE3("  Found Clip = 0x%04X[%s] len=%d \n", r, GetFormatName(r), v.GetSize());
            }
            else
            {
                TRACE2("  Drop Clip = 0x%04X[%s]\n", r, GetFormatName(r));
            }
            uFormat = r;
        }
        m_Close();
        return boRc;
    }
 
    bool SetAll(const CDataMap& data)
    {
        if ( ! m_Open(true) )
        {
            return false;
        }
        bool boRc = true;
        UINT uFormat;
        CVectorT<BYTE> v;
        loop ( i, data.GetSize() )
        {
            VERIFYLIB(data.Get(i, uFormat, v));
            bool boIsValid = false;
            switch ( uFormat )
            {
            case CF_TEXT:
            case CF_UNICODETEXT:
            case CF_OEMTEXT:
            case CF_DIB:        //CF_BITMAP CF_PALETTE CF_DIBV5 と同期
                boIsValid = true;
                break;
#ifndef _WIN32_WCE
            case CF_ENHMETAFILE:    //CF_METAFILEPICT と同期
                {
                    HENHMETAFILE h = ::SetEnhMetaFileBits(ToDword(v.GetSize()), v.ReferBuffer());
                    boRc &= m_SetData(uFormat, h);
                }
                break;
#endif
            default:
                break;
            }
            if ( uFormat >= 0x8000 || boIsValid )
            {
 
#ifdef _WIN32_WCE
                if ( uFormat == CF_TEXT )
                {
                    LPCSTR P = reinterpret_cast<LPCSTR>(v.ReferBuffer());
                    CUnicode u = P;
                    size_t l = u.GetLength() * 2;
                    LPCWSTR lpsz = u;
                    MemCopy(v.GetBuffer(l), lpsz, l);
                    v.ReleaseBuffer();
                    uFormat = CF_UNICODETEXT;
                }
#endif
                HGLOBAL hMem = m_AllocAndCopy(v.GetSize(), v.ReferBuffer());
                boRc &= m_SetData(uFormat, hMem);
            }           
        }
        m_Close();
        return boRc;
    }
 
    #endif // _TnbCLIPBOARD_OtherType_ENABLE
 
private:
 
    #ifdef _UNICODE
        enum { CBFMT_TEXT = CF_UNICODETEXT };
    #else   
        enum { CBFMT_TEXT = CF_TEXT };
    #endif
 
    HWND    m_hWnd;         
    DWORD   m_dwOpenTimeout;
    bool    m_boHasErrBox;  
 
    void m_MsgBox(LPCTSTR lpsz) const
    {
        if ( m_boHasErrBox )
        {
            TRACE1("%s\n", lpsz);
            ::MessageBox(NULL, lpsz, _T("TNB::CClipboard"), MB_OK); 
        }
    }
 
    bool m_Open(bool boWithEmpty = false) const
    {
        DWORD dwTick = ::GetTickCount();
        do
        {
            if ( ::OpenClipboard(m_hWnd) )
            {
                if ( boWithEmpty && ! ::EmptyClipboard() )
                {
                    ::CloseClipboard();
                    m_MsgBox(_T("クリップ・ボードが一杯です"));
                    return false;
                }
                return true;
            }
            ::Sleep(1);
        }
        while ( (::GetTickCount() - dwTick) < m_dwOpenTimeout );
        m_MsgBox(_T("クリップ・ボードが利用できません。"));
        return false;
    }
 
    void m_Close(void) const
    {
        ::CloseClipboard(); 
    }
 
    HGLOBAL m_AllocAndCopy(size_t size, LPCVOID P)
    {
        HGLOBAL hMem = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, size);
        if ( hMem == NULL ) 
        {
            m_MsgBox(_T("メモリが一杯です"));
        }
        else
        {
            ::CopyMemory(GlobalLock(hMem), P, size);
            GlobalUnlock(hMem);
        }
        return hMem;
    }
 
    bool m_SetData(UINT uFormat, HGLOBAL hMem)
    {
        if ( hMem == NULL )
        {
            return false;
        }
        if ( ::SetClipboardData(uFormat, hMem) == NULL )
        {
            ::GlobalFree(hMem);
            return false;
        }
        return true;
    }
};
 
 
 
}; // TNB