ref: 9eaba52cafcac7c2f3bfc72d7be1f15893196be1
dir: /DoConfig/fltk/src/fl_dnd_win32.cxx/
//
// "$Id$"
//
// Drag & Drop code for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2010 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// http://www.fltk.org/COPYING.php
//
// Please report all bugs and problems on the following page:
//
// http://www.fltk.org/str.php
//
// This file contains win32-specific code for fltk which is always linked
// in. Search other files for "WIN32" or filenames ending in _win32.cxx
// for other system-specific code.
#include <FL/Fl.H>
#include <FL/x.H>
#include <FL/Fl_Window.H>
#include <FL/fl_utf8.h>
#include "flstring.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <objidl.h>
#include <time.h>
#if defined(__CYGWIN__)
#include <sys/time.h>
#include <unistd.h>
#endif
extern char *fl_selection_buffer[2];
extern int fl_selection_length[2];
extern int fl_selection_buffer_length[2];
extern char fl_i_own_selection[2];
extern char *fl_locale2utf8(const char *s, UINT codepage = 0);
extern unsigned int fl_codepage;
Fl_Window *fl_dnd_target_window = 0;
#include <ole2.h>
#include <shellapi.h>
#include <shlobj.h>
/**
* subclass the IDropTarget to receive data from DnD operations
*/
class FLDropTarget : public IDropTarget
{
DWORD m_cRefCount;
DWORD lastEffect;
int px, py;
public:
FLDropTarget() : m_cRefCount(0) { } // initialize
virtual ~FLDropTarget() { }
HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, LPVOID *ppvObject ) {
if (IID_IUnknown==riid || IID_IDropTarget==riid)
{
*ppvObject=this;
((LPUNKNOWN)*ppvObject)->AddRef();
return S_OK;
}
*ppvObject = NULL;
return E_NOINTERFACE;
}
ULONG STDMETHODCALLTYPE AddRef() { return ++m_cRefCount; }
ULONG STDMETHODCALLTYPE Release() {
long nTemp;
nTemp = --m_cRefCount;
if(nTemp==0)
delete this;
return nTemp;
}
HRESULT STDMETHODCALLTYPE DragEnter( IDataObject *pDataObj, DWORD /*grfKeyState*/, POINTL pt, DWORD *pdwEffect) {
if( !pDataObj ) return E_INVALIDARG;
/* Tricky point here: Not DPI-aware applications use different units for the 'POINTL pt' argument
of the DragEnter, DragOver, and Drop member functions.
DragEnter receives the mouse coordinates in unscaled screen units,
whereas DragOver and Drop receive the mouse coordinates in scaled units.
This looks like a Windows bug because these apps are supposed to always receive
scaled units from the OS.
Therefore, we ask here for the mouse coordinates.
*/
POINT mp;
GetCursorPos(&mp);
pt.x = mp.x; pt.y = mp.y;
// set e_modifiers here from grfKeyState, set e_x and e_root_x
// check if FLTK handles this drag and return if it can't (i.e. BMP drag without filename)
POINT ppt;
Fl::e_x_root = ppt.x = pt.x;
Fl::e_y_root = ppt.y = pt.y;
HWND hWnd = WindowFromPoint( ppt );
Fl_Window *target = fl_find( hWnd );
if (target) {
Fl::e_x = Fl::e_x_root-target->x();
Fl::e_y = Fl::e_y_root-target->y();
}
fl_dnd_target_window = target;
px = pt.x; py = pt.y;
if (fillCurrentDragData(pDataObj)) {
// FLTK has no mechanism yet for the different drop effects, so we allow move and copy
if ( target && Fl::handle( FL_DND_ENTER, target ) )
*pdwEffect = DROPEFFECT_MOVE|DROPEFFECT_COPY; //|DROPEFFECT_LINK;
else
*pdwEffect = DROPEFFECT_NONE;
} else {
*pdwEffect = DROPEFFECT_NONE;
}
lastEffect = *pdwEffect;
return S_OK;
}
HRESULT STDMETHODCALLTYPE DragOver( DWORD /*grfKeyState*/, POINTL pt, DWORD *pdwEffect) {
if ( px==pt.x && py==pt.y )
{
*pdwEffect = lastEffect;
return S_OK;
}
if ( !fl_dnd_target_window )
{
*pdwEffect = lastEffect = DROPEFFECT_NONE;
return S_OK;
}
// set e_modifiers here from grfKeyState, set e_x and e_root_x
Fl::e_x_root = pt.x;
Fl::e_y_root = pt.y;
if (fl_dnd_target_window) {
Fl::e_x = Fl::e_x_root-fl_dnd_target_window->x();
Fl::e_y = Fl::e_y_root-fl_dnd_target_window->y();
}
if (fillCurrentDragData(0)) {
// Fl_Group will change DND_DRAG into DND_ENTER and DND_LEAVE if needed
if ( Fl::handle( FL_DND_DRAG, fl_dnd_target_window ) )
*pdwEffect = DROPEFFECT_MOVE|DROPEFFECT_COPY; //|DROPEFFECT_LINK;
else
*pdwEffect = DROPEFFECT_NONE;
} else {
*pdwEffect = DROPEFFECT_NONE;
}
px = pt.x; py = pt.y;
lastEffect = *pdwEffect;
// show insert position if dnd'ing in the same window/process (STR #3209)
Fl::flush();
return S_OK;
}
HRESULT STDMETHODCALLTYPE DragLeave() {
if ( fl_dnd_target_window && fillCurrentDragData(0))
{
Fl::handle( FL_DND_LEAVE, fl_dnd_target_window );
fl_dnd_target_window = 0;
clearCurrentDragData();
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE Drop( IDataObject *data, DWORD /*grfKeyState*/, POINTL pt, DWORD* /*pdwEffect*/) {
if ( !fl_dnd_target_window )
return S_OK;
Fl_Window *target = fl_dnd_target_window;
fl_dnd_target_window = 0;
Fl::e_x_root = pt.x;
Fl::e_y_root = pt.y;
if (target) {
Fl::e_x = Fl::e_x_root-target->x();
Fl::e_y = Fl::e_y_root-target->y();
}
// tell FLTK that the user released an object on this widget
if ( !Fl::handle( FL_DND_RELEASE, target ) )
return S_OK;
Fl_Widget *w = target;
while (w->parent()) w = w->window();
HWND hwnd = fl_xid( (Fl_Window*)w );
if (fillCurrentDragData(data)) {
int old_event = Fl::e_number;
char *a, *b;
a = b = currDragData;
while (*a) { // strip the CRLF pairs
if (*a == '\r' && a[1] == '\n') a++;
else *b++ = *a++;
}
*b = 0;
Fl::e_text = currDragData;
Fl::e_length = (int) (b - currDragData);
Fl::belowmouse()->handle(Fl::e_number = FL_PASTE); // e_text will be invalid after this call
Fl::e_number = old_event;
SetForegroundWindow( hwnd );
clearCurrentDragData();
return S_OK;
}
return S_OK;
}
private:
static IDataObject *currDragRef;
static char *currDragData;
static int currDragSize;
static char currDragResult;
static void clearCurrentDragData() {
currDragRef = 0;
if (currDragData) free(currDragData);
currDragData = 0;
currDragSize = 0;
currDragResult = 0;
}
static char fillCurrentDragData(IDataObject *data) {
// shortcut through this whole procedure if there is no fresh data
if (!data)
return currDragResult;
// shortcut through this whole procedure if this is still the same drag event
// (* this is safe, because 'currDragRef' is cleared on Leave and Drop events)
if (data==currDragRef)
return currDragResult;
// clear currDrag* for a new drag event
clearCurrentDragData();
currDragRef = data;
// fill currDrag* with UTF-8 data, if available
FORMATETC fmt = { 0 };
STGMEDIUM medium = { 0 };
fmt.tymed = TYMED_HGLOBAL;
fmt.dwAspect = DVASPECT_CONTENT;
fmt.lindex = -1;
fmt.cfFormat = CF_UNICODETEXT;
// if it is UNICODE text, return a UTF-8-converted copy of it
if ( data->GetData( &fmt, &medium )==S_OK )
{
void *stuff = GlobalLock( medium.hGlobal );
unsigned srclen = 0;
const wchar_t *wstuff = (const wchar_t *)stuff;
while (*wstuff++) srclen++;
wstuff = (const wchar_t *)stuff;
unsigned utf8len = fl_utf8fromwc(NULL, 0, wstuff, srclen);
currDragSize = utf8len;
currDragData = (char*)malloc(utf8len + 1);
fl_utf8fromwc(currDragData, currDragSize+1, wstuff, srclen+1); // include null-byte
GlobalUnlock( medium.hGlobal );
ReleaseStgMedium( &medium );
currDragResult = 1;
return currDragResult;
}
fmt.cfFormat = CF_TEXT;
// if it is CP1252 text, return a UTF-8-converted copy of it
if ( data->GetData( &fmt, &medium )==S_OK )
{
int len;
char *p, *q, *last;
unsigned u;
void *stuff = GlobalLock( medium.hGlobal );
currDragData = (char*)malloc(3 * strlen((char*)stuff) + 10);
p = (char*)stuff;
last = p + strlen(p);
q = currDragData;
while (p < last) {
u = fl_utf8decode(p, last, &len);
p += len;
len = fl_utf8encode(u, q);
q += len;
}
*q = 0;
currDragSize = (int) (q - currDragData);
currDragData = (char*)realloc(currDragData, currDragSize + 1);
GlobalUnlock( medium.hGlobal );
ReleaseStgMedium( &medium );
currDragResult = 1;
return currDragResult;
}
// else fill currDrag* with filenames, if possible
memset(&fmt, 0, sizeof(fmt));
fmt.tymed = TYMED_HGLOBAL;
fmt.dwAspect = DVASPECT_CONTENT;
fmt.lindex = -1;
fmt.cfFormat = CF_HDROP;
// if it is a pathname list, send an FL_PASTE with a \n separated list of filepaths
if ( data->GetData( &fmt, &medium )==S_OK )
{
HDROP hdrop = (HDROP)medium.hGlobal;
int i, n, nn = 0, nf = DragQueryFileW( hdrop, (UINT)-1, 0, 0 );
for ( i=0; i<nf; i++ ) nn += DragQueryFileW( hdrop, i, 0, 0 );
nn += nf;
xchar *dst = (xchar *)malloc(nn * sizeof(xchar));
xchar *bu = dst;
for ( i=0; i<nf; i++ ) {
n = DragQueryFileW( hdrop, i, (WCHAR*)dst, nn );
dst += n;
if ( i<nf-1 ) {
*dst++ = L'\n';
}
}
*dst=0;
currDragData = (char*) malloc(nn * 5 + 1);
// Fl::e_length = fl_unicode2utf(bu, nn, Fl::e_text);
currDragSize = fl_utf8fromwc(currDragData, (nn*5+1), bu, nn);
currDragData[currDragSize] = 0;
free(bu);
// Fl::belowmouse()->handle(FL_DROP);
// free( Fl::e_text );
ReleaseStgMedium( &medium );
currDragResult = 1;
return currDragResult;
}
currDragResult = 0;
return currDragResult;
}
} flDropTarget;
IDropTarget *flIDropTarget = &flDropTarget;
IDataObject *FLDropTarget::currDragRef = 0;
char *FLDropTarget::currDragData = 0;
int FLDropTarget::currDragSize = 0;
char FLDropTarget::currDragResult = 0;
/**
* this class is needed to allow FLTK apps to be a DnD source
*/
class FLDropSource : public IDropSource
{
DWORD m_cRefCount;
public:
FLDropSource() { m_cRefCount = 0; }
virtual ~FLDropSource() { }
HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, LPVOID *ppvObject ) {
if (IID_IUnknown==riid || IID_IDropSource==riid)
{
*ppvObject=this;
((LPUNKNOWN)*ppvObject)->AddRef();
return S_OK;
}
*ppvObject = NULL;
return E_NOINTERFACE;
}
ULONG STDMETHODCALLTYPE AddRef() { return ++m_cRefCount; }
ULONG STDMETHODCALLTYPE Release() {
long nTemp;
nTemp = --m_cRefCount;
if(nTemp==0)
delete this;
return nTemp;
}
STDMETHODIMP GiveFeedback( DWORD ) { return DRAGDROP_S_USEDEFAULTCURSORS; }
STDMETHODIMP QueryContinueDrag( BOOL esc, DWORD keyState ) {
if ( esc )
return DRAGDROP_S_CANCEL;
if ( !(keyState & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON)) )
return DRAGDROP_S_DROP;
return S_OK;
}
};
class FLEnum : public IEnumFORMATETC
{
public:
int n;
LONG m_lRefCount;
ULONG __stdcall AddRef(void) {
return InterlockedIncrement(&m_lRefCount);
}
ULONG __stdcall Release(void) {
LONG count = InterlockedDecrement(&m_lRefCount);
if(count == 0) {
delete this;
return 0;
} else {
return count;
}
}
HRESULT __stdcall QueryInterface(REFIID iid, void **ppvObject) {
if(iid == IID_IEnumFORMATETC || iid == IID_IUnknown) {
AddRef();
*ppvObject = this;
return S_OK;
} else {
*ppvObject = 0;
return E_NOINTERFACE;
}
}
HRESULT __stdcall Next(ULONG celt, FORMATETC * rgelt, ULONG *pceltFetched) {
if (n > 0) return S_FALSE;
for (ULONG i = 0; i < celt; i++) {
n++;
rgelt->cfFormat = CF_HDROP;
rgelt->dwAspect = DVASPECT_CONTENT;
rgelt->lindex = -1;
rgelt->ptd = NULL;
rgelt->tymed = TYMED_HGLOBAL;
}
if (pceltFetched) *pceltFetched = celt;
return S_OK;
}
HRESULT __stdcall Skip(ULONG celt) {
n += celt;
return (n == 0) ? S_OK : S_FALSE;
}
HRESULT __stdcall Reset(void) {
n = 0;
return S_OK;
}
HRESULT __stdcall Clone(IEnumFORMATETC **ppenum){
*ppenum = new FLEnum();
return S_OK;
}
FLEnum(void) {
m_lRefCount = 1;
n = 0;
}
virtual ~FLEnum(void) {
n = 0;
}
};
/**
This is the actual object that FLTK can drop somewhere.
The implementation is minimal, but it should work with all decent Win32 drop targets
*/
class FLDataObject : public IDataObject
{
DWORD m_cRefCount;
FLEnum *m_EnumF;
public:
FLDataObject() { m_cRefCount = 1; }// m_EnumF = new FLEnum();}
virtual ~FLDataObject() { }
HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, LPVOID *ppvObject ) {
if (IID_IUnknown==riid || IID_IDataObject==riid)
{
*ppvObject=this;
((LPUNKNOWN)*ppvObject)->AddRef();
return S_OK;
}
*ppvObject = NULL;
return E_NOINTERFACE;
}
ULONG STDMETHODCALLTYPE AddRef() { return ++m_cRefCount; }
ULONG STDMETHODCALLTYPE Release() {
long nTemp;
nTemp = --m_cRefCount;
if(nTemp==0)
delete this;
return nTemp;
}
// GetData currently allows UNICODE text through Global Memory only
HRESULT STDMETHODCALLTYPE GetData( FORMATETC *pformatetcIn, STGMEDIUM *pmedium ) {
if ((pformatetcIn->dwAspect & DVASPECT_CONTENT) &&
(pformatetcIn->tymed & TYMED_HGLOBAL) &&
(pformatetcIn->cfFormat == CF_UNICODETEXT))
{
int utf16_len = fl_utf8toUtf16(fl_selection_buffer[0], fl_selection_length[0], 0, 0);
HGLOBAL gh = GlobalAlloc( GHND, utf16_len * 2 + 2 );
char *pMem = (char*)GlobalLock( gh );
fl_utf8toUtf16(fl_selection_buffer[0], fl_selection_length[0], (unsigned short*)pMem, utf16_len + 1);
// HGLOBAL gh = GlobalAlloc( GHND| GMEM_SHARE,
// (fl_selection_length[0]+4) * sizeof(short)
// + sizeof(DROPFILES));
// unsigned char *pMem = (unsigned char*)GlobalLock( gh );
// if (!pMem) {
// GlobalFree(gh);
// return DV_E_FORMATETC;
// }
// DROPFILES *df =(DROPFILES*) pMem;
// int l;
// df->pFiles = sizeof(DROPFILES);
// df->pt.x = 0;
// df->pt.y = 0;
// df->fNC = FALSE;
// for (int i = 0; i < fl_selection_length[0]; i++) {
// if (fl_selection_buffer[0][i] == '\n') {
// fl_selection_buffer[0][i] = '\0';
// }
// }
//
// df->fWide = TRUE;
// l = fl_utf2unicode((unsigned char*)fl_selection_buffer[0],
// fl_selection_length[0], (xchar*)(((char*)pMem)
// + sizeof(DROPFILES)));
//
// pMem[l * sizeof(WCHAR) + sizeof(DROPFILES)] = 0;
// pMem[l * sizeof(WCHAR) + 1 + sizeof(DROPFILES)] = 0;
// pMem[l * sizeof(WCHAR) + 2 + sizeof(DROPFILES)] = 0;
// pMem[l * sizeof(WCHAR) + 3 + sizeof(DROPFILES)] = 0;
pmedium->tymed = TYMED_HGLOBAL;
pmedium->hGlobal = gh;
pmedium->pUnkForRelease = NULL;
GlobalUnlock( gh );
return S_OK;
}
return DV_E_FORMATETC;
}
HRESULT STDMETHODCALLTYPE QueryGetData( FORMATETC *pformatetc )
{
if ((pformatetc->dwAspect & DVASPECT_CONTENT) &&
(pformatetc->tymed & TYMED_HGLOBAL) &&
(pformatetc->cfFormat == CF_UNICODETEXT))
return S_OK;
return DV_E_FORMATETC;
}
// HRESULT STDMETHODCALLTYPE EnumFormatEtc( DWORD dir, IEnumFORMATETC** ppenumFormatEtc) {
// *ppenumFormatEtc = m_EnumF;
// return S_OK;
// }
// all the following methods are not really needed for a DnD object
HRESULT STDMETHODCALLTYPE GetDataHere( FORMATETC* /*pformatetcIn*/, STGMEDIUM* /*pmedium*/) { return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc( FORMATETC* /*in*/, FORMATETC* /*out*/) { return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE SetData( FORMATETC* /*pformatetc*/, STGMEDIUM* /*pmedium*/, BOOL /*fRelease*/) { return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE EnumFormatEtc( DWORD /*dir*/, IEnumFORMATETC** /*ppenumFormatEtc*/) { return E_NOTIMPL; }
// HRESULT STDMETHODCALLTYPE EnumFormatEtc( DWORD dir, IEnumFORMATETC** ppenumFormatEtc) {*ppenumFormatEtc = m_EnumF; return S_OK;}
HRESULT STDMETHODCALLTYPE DAdvise( FORMATETC* /*pformatetc*/, DWORD /*advf*/,
IAdviseSink* /*pAdvSink*/, DWORD* /*pdwConnection*/) { return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE DUnadvise( DWORD /*dwConnection*/) { return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE EnumDAdvise( IEnumSTATDATA** /*ppenumAdvise*/) { return E_NOTIMPL; }
};
int Fl::dnd()
{
DWORD dropEffect;
ReleaseCapture();
FLDataObject *fdo = new FLDataObject;
fdo->AddRef();
FLDropSource *fds = new FLDropSource;
fds->AddRef();
HRESULT ret = DoDragDrop( fdo, fds, DROPEFFECT_MOVE|DROPEFFECT_LINK|DROPEFFECT_COPY, &dropEffect );
fdo->Release();
fds->Release();
Fl_Widget *w = Fl::pushed();
if ( w )
{
int old_event = Fl::e_number;
w->handle(Fl::e_number = FL_RELEASE);
Fl::e_number = old_event;
Fl::pushed( 0 );
}
if ( ret==DRAGDROP_S_DROP ) return 1; // or DD_S_CANCEL
return 0;
}
//
// End of "$Id$".
//