DragSource Lib for BCB(DragDrop.cpp)

//---------------------------------------------------------------------------
// DragSource Lib.
// Copyright (c) 2006, 2007 by Mao yongjun
// All rights reserved
// Add "WINOLEAPI OleInitialize (LPVOID pvReserved)" before use DragDropLib on each thread
// Don't forget "WINOLEAPI OleUninitialize ()" on exit the thread
//---------------------------------------------------------------------------

#pragma hdrstop

#include "DragDrop.h"
#pragma package(smart_init)

void* THDROP_Files::Create_HDROP() const
...{
    struct TMyDropFiles...{
        DWORD pFiles;
        POINT pt;
        BOOL fNC;
        BOOL fWide;
        char szFiles[1];
    };

    size_t MemSize=0;
    for(const_iterator i=begin();i!=end();i++)
    ...{
        MemSize+=i->length();
        MemSize++;
    }

    void* ptr=GlobalAlloc(GMEM_FIXED,sizeof(TMyDropFiles)+MemSize);
    ZeroMemory(ptr,sizeof(TMyDropFiles)+MemSize);

    TMyDropFiles *FileNames=new (ptr)TMyDropFiles;
    FileNames->pFiles=(unsigned)FileNames->szFiles - (unsigned)(&FileNames->pFiles);

    char *p=FileNames->szFiles;
    for(const_iterator i=begin();i!=end();i++)
    ...{
        size_t len=i->length();
        CopyMemory(p,i->c_str(),len);
        p+=len;
        *(p++)=0;
    }
    *p=0;

    return ptr;
}
//------------------------------TDropSource---------------------------------------------
HANDLE MemToHandle (void *pMem, int nSize)
...{
    void* ptr=GlobalAlloc(GMEM_FIXED, nSize);
    CopyMemory(ptr, pMem, nSize);
    return ptr;
}

HRESULT __stdcall TDropSource::QueryInterface(REFIID iid, void **ppv)
...{
    if((iid==IID_IUnknown)||(iid==IID_IDropSource))
    ...{
        *ppv=this;
        AddRef();
    }
    else
    ...{
        *ppv=NULL;
        return E_NOINTERFACE;
    }
    return S_OK;
}

HRESULT __stdcall TDropSource::QueryContinueDrag(BOOL fEscapePressed,DWORD grfKeyState)
...{
    return fEscapePressed?DRAGDROP_S_CANCEL:((grfKeyState&MK_LBUTTON)?S_OK:DRAGDROP_S_DROP);
}

HRESULT __stdcall TDropSource::GiveFeedback(DWORD dwEffect)
...{
    return DRAGDROP_S_USEDEFAULTCURSORS;
}
//-------------------------------TDataObject--------------------------------------------
HGLOBAL DupGlobalMem (HGLOBAL hMem)
...{
    DWORD   len    = GlobalSize (hMem);
    PVOID   source = GlobalLock (hMem);
    PVOID   dest   = GlobalAlloc (GMEM_FIXED, len);
    memcpy (dest, source, len);
    GlobalUnlock (hMem);
    return dest;
}

HRESULT CreateDataObject (FORMATETC *fmtetc, STGMEDIUM *stgmeds, UINT count, IDataObject **ppDataObject)
...{
    if(ppDataObject == 0)
        return E_INVALIDARG;

    *ppDataObject = new TDataObject;
    ((TDataObject *)(*ppDataObject))->Add(fmtetc, stgmeds, count);
    return (*ppDataObject) ? S_OK : E_OUTOFMEMORY;
}

HRESULT __stdcall TDataObject::QueryInterface(REFIID iid, void **ppv)
...{
    if((iid==IID_IUnknown)||(iid==IID_IDataObject))
    ...{
        *ppv=this;
        AddRef();
        return S_OK;
    }
    else
    ...{
        *ppv=NULL;
        return E_NOINTERFACE;
    }
}

HRESULT __stdcall TDataObject::QueryGetData(FORMATETC *pFormatEtc)
...{
    return (LookupFormatEtc(pFormatEtc) == -1) ? DV_E_FORMATETC : S_OK;
}

HRESULT __stdcall TDataObject::GetData (FORMATETC *pFormatEtc, STGMEDIUM *pStgMedium)
...{
    int idx;
    if((idx = LookupFormatEtc(pFormatEtc)) == -1)
        return DV_E_FORMATETC;

    pStgMedium->tymed           = _pFormatEtc[idx].tymed;
    pStgMedium->pUnkForRelease  = 0;

    switch(_pFormatEtc[idx].tymed)
    ...{
    case TYMED_HGLOBAL:
        pStgMedium->hGlobal = DupGlobalMem(_pStgMedium[idx].hGlobal);
        break;
    case TYMED_GDI:
        pStgMedium->hBitmap = CopyImage(_pStgMedium[idx].hBitmap,IMAGE_BITMAP,0,0,0);
        break;
    default:
        return DV_E_FORMATETC;
    }
    return S_OK;
}

int TDataObject::LookupFormatEtc(FORMATETC *pFormatEtc)
...{
    // 轮流检查格式看是否能找到匹配的格式
    for(size_t i = 0; i < _pFormatEtc.size(); i++)
    ...{
        if((_pFormatEtc[i].tymed & pFormatEtc->tymed)   &&
            _pFormatEtc[i].cfFormat == pFormatEtc->cfFormat &&
            _pFormatEtc[i].dwAspect == pFormatEtc->dwAspect)
        ...{
            return i;
        }
    }
    return -1;
}

HRESULT __stdcall TDataObject::EnumFormatEtc (DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
...{
    // OLE仅仅支持得到方向成员
    if(dwDirection == DATADIR_GET)
    ...{
        // 在WIN2K下，你可以调用API函数SHCreateStdEnumFmtEtc来完成，但为了支持//所有的window平台，我们需要实现IEnumFormatEtc。
        return CreateEnumFormatEtc(_pFormatEtc.size(), &_pFormatEtc[0], ppEnumFormatEtc);
    }
    else
    ...{
        // the direction specified is not supported for drag+drop
        return E_NOTIMPL;
    }
}

void TDataObject::Add(CLIPFORMAT ctFormat,DWORD tymed,void *hStorage)
...{
    FORMATETC fmtetc = ...{
        ctFormat,            // we will be dropping some text
        0,
        DVASPECT_CONTENT,
        -1,
        tymed       // stored as a HGLOBAL
    };
    STGMEDIUM stgmed = ...{
        tymed,
        ...{hStorage},
        0
    };
    _pFormatEtc.push_back(fmtetc);
    _pStgMedium.push_back(stgmed);
}

void TDataObject::Add(FORMATETC *fmtetc, STGMEDIUM *stgmeds, UINT count=1)
...{
    for(UINT i=0;i<count;i++)
    ...{
        _pFormatEtc.push_back(fmtetc[i]);
        _pStgMedium.push_back(stgmeds[i]);
    }
}
void TDataObject::Clear()
...{
    _pFormatEtc.clear();
    _pStgMedium.clear();
}
void TDataObject::ClearAndRelease()
...{
    for(size_t i=0;i<_pFormatEtc.size();i++)
        ReleaseStgMedium(&_pStgMedium[i]);
    Clear();
}


//-------------------------------TEnumFormatEtc--------------------------------------------
HRESULT CreateEnumFormatEtc (UINT cfmt, FORMATETC *afmt, IEnumFORMATETC **ppEnumFormatEtc)
...{
    if (cfmt == 0 || afmt == 0 || ppEnumFormatEtc == 0)
        return E_INVALIDARG;
    *ppEnumFormatEtc = new TEnumFormatEtc (afmt, cfmt);
    if(*ppEnumFormatEtc)
    ...{
        return S_OK;
    }
    else
    ...{
        return E_OUTOFMEMORY;
    }
}

void DeepCopyFormatEtc(FORMATETC *dest, FORMATETC *source)
...{
    // copy the source FORMATETC into dest
    *dest = *source;
    if(source->ptd)
    ...{
        // allocate memory for the DVTARGETDEVICE if necessary
        dest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
        // copy the contents of the source DVTARGETDEVICE into dest->ptd
        *(dest->ptd) = *(source->ptd);
    }
}
TEnumFormatEtc::TEnumFormatEtc(FORMATETC *pFormatEtc, ULONG nNumFormats)
    :_iRefCount(1),_nIndex(0),_nNumFormats(nNumFormats)
...{
    _pFormatEtc  = new FORMATETC[nNumFormats];
    // make a new copy of each FORMATETC structure
    for(ULONG i = 0; i < nNumFormats; i++)
    ...{
        DeepCopyFormatEtc (&_pFormatEtc[i], &pFormatEtc[i]);
    }
}
TEnumFormatEtc::~TEnumFormatEtc()
...{
    // first free any DVTARGETDEVICE structures
    for(ULONG i = 0; i < _nNumFormats; i++)
    ...{
        if(_pFormatEtc[i].ptd)
            CoTaskMemFree(_pFormatEtc[i].ptd);
    }
    // now free the main array
    delete[] _pFormatEtc;
}
HRESULT __stdcall TEnumFormatEtc::Next(ULONG celt, FORMATETC *pFormatEtc, ULONG *pceltFetched)
...{
    ULONG copied = 0;
    // copy the FORMATETC structures into the caller's buffer
    while (_nIndex < _nNumFormats && copied < celt)
    ...{
        DeepCopyFormatEtc (&pFormatEtc [copied], &_pFormatEtc [_nIndex]);
        copied++;
        _nIndex++;
    }
    // store result
    if(pceltFetched != 0) 
        *pceltFetched = copied;
    // did we copy all that was requested?
    return (copied == celt) ? S_OK : S_FALSE;
}

TDropResult DoDragDrop(FORMATETC *fmtetc, STGMEDIUM *stgmeds,UINT count,DWORD dwOKEffect)
...{
    IDropSource *pDropSource=new TDropSource;
    TDataObject *pDataObject=new TDataObject();
    pDataObject->Add(fmtetc, stgmeds, count);
    DWORD dwEffect;
    DWORD dwResult = DoDragDrop(pDataObject, pDropSource, dwOKEffect, &dwEffect);

    pDropSource->Release();
    pDataObject->Release();

    TDropResult Result=...{dwResult,dwEffect};
    return Result;
}

TDropResult DoDragDrop(CLIPFORMAT ctFormat,DWORD tymed,void *hStorage,DWORD dwOKEffect)
...{
    FORMATETC fmtetc = ...{
        ctFormat,
        0,
        DVASPECT_CONTENT,
        -1,
        tymed
    };
    STGMEDIUM stgmed = ...{
        tymed,
        ...{hStorage},
        0
    };
    TDropResult Result= DoDragDrop(&fmtetc,&stgmed,1,dwOKEffect);
    ReleaseStgMedium(&stgmed);
    return Result;
}

TDropResult DoDragDrop(char *szText,DWORD dwOKEffect)
...{
    return DoDragDrop(
        CF_TEXT,
        TYMED_HGLOBAL,
        MemToHandle(szText, strlen(szText)+1),               //Freed
        dwOKEffect
        );
}

TDropResult DoDragDropURL(char *URL,DWORD dwOKEffect)
...{
    return DoDragDrop(
        RegisterClipboardFormat("UniformResourceLocator"),
        TYMED_HGLOBAL,
        MemToHandle(URL, strlen(URL)+1),               //Freed
        dwOKEffect
        );
}

TDropResult DoDragDrop(wchar_t *wszText,DWORD dwOKEffect)
...{
    return DoDragDrop(
        CF_UNICODETEXT,
        TYMED_HGLOBAL,
        MemToHandle (wszText, wcslen(wszText)*2+2),         //Freed
        dwOKEffect
        );
}

TDropResult DoDragDrop(HBITMAP hBitmap,DWORD dwOKEffect)
...{
    FORMATETC fmtetc = ...{
        CF_BITMAP,
        0,
        DVASPECT_CONTENT,
        -1,
        TYMED_GDI
    };
    STGMEDIUM stgmed = ...{
        TYMED_GDI,
        ...{hBitmap},
        0
    };
    TDropResult Result = DoDragDrop(&fmtetc,&stgmed,1,dwOKEffect);
    return Result;
}

TDropResult DoDragDrop(const THDROP_Files &files,
        DWORD dwOKEffect)
...{
    return DoDragDrop(
        CF_HDROP,
        TYMED_HGLOBAL,
        files.Create_HDROP(),
        dwOKEffect
        );
}