]> git.saurik.com Git - wxWidgets.git/blob - src/msw/ole/droptgt.cpp
Whole lotta stuff for wxPlotWindow,
[wxWidgets.git] / src / msw / ole / droptgt.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: ole/droptgt.cpp
3 // Purpose: wxDropTarget implementation
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created:
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // Declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "droptgt.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #if defined(__BORLANDC__)
28 #pragma hdrstop
29 #endif
30
31 #include "wx/setup.h"
32
33 #if wxUSE_DRAG_AND_DROP
34
35 #include "wx/log.h"
36
37 #ifdef __WIN32__
38 #ifndef __GNUWIN32__
39 #include <shlobj.h> // for DROPFILES structure
40 #endif
41 #else
42 #include <shellapi.h>
43 #endif
44
45 #include "wx/dnd.h"
46
47 #ifndef __WIN32__
48 #include <ole2.h>
49 #include <olestd.h>
50 #endif
51
52 #include "wx/msw/ole/oleutils.h"
53
54 // ----------------------------------------------------------------------------
55 // IDropTarget interface: forward all interesting things to wxDropTarget
56 // (the name is unfortunate, but wx_I_DropTarget is not at all the same thing
57 // as wxDropTarget which is 'public' class, while this one is private)
58 // ----------------------------------------------------------------------------
59
60 class wxIDropTarget : public IDropTarget
61 {
62 public:
63 wxIDropTarget(wxDropTarget *p);
64 ~wxIDropTarget();
65
66 // accessors for wxDropTarget
67 void SetHwnd(HWND hwnd) { m_hwnd = hwnd; }
68
69 // IDropTarget methods
70 STDMETHODIMP DragEnter(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
71 STDMETHODIMP DragOver(DWORD, POINTL, LPDWORD);
72 STDMETHODIMP DragLeave();
73 STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
74
75 DECLARE_IUNKNOWN_METHODS;
76
77 protected:
78 IDataObject *m_pIDataObject; // !NULL between DragEnter and DragLeave/Drop
79 wxDropTarget *m_pTarget; // the real target (we're just a proxy)
80
81 HWND m_hwnd; // window we're associated with
82
83 // get default drop effect for given keyboard flags
84 static inline DWORD GetDropEffect(DWORD flags);
85 };
86
87 // ----------------------------------------------------------------------------
88 // private functions
89 // ----------------------------------------------------------------------------
90
91 static wxDragResult ConvertDragEffectToResult(DWORD dwEffect);
92 static DWORD ConvertDragResultToEffect(wxDragResult result);
93
94 // ============================================================================
95 // wxIDropTarget implementation
96 // ============================================================================
97
98 // Name : static wxIDropTarget::GetDropEffect
99 // Purpose : determine the drop operation from keyboard/mouse state.
100 // Returns : DWORD combined from DROPEFFECT_xxx constants
101 // Params : [in] DWORD flags kbd & mouse flags as passed to
102 // IDropTarget methods
103 // Notes : We do "move" normally and "copy" if <Ctrl> is pressed,
104 // which is the standard behaviour (currently there is no
105 // way to redefine it)
106 DWORD wxIDropTarget::GetDropEffect(DWORD flags)
107 {
108 return flags & MK_CONTROL ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
109 }
110
111 wxIDropTarget::wxIDropTarget(wxDropTarget *pTarget)
112 {
113 m_cRef = 0;
114 m_pTarget = pTarget;
115 m_pIDataObject = NULL;
116 }
117
118 wxIDropTarget::~wxIDropTarget()
119 {
120 }
121
122 BEGIN_IID_TABLE(wxIDropTarget)
123 ADD_IID(Unknown)
124 ADD_IID(DropTarget)
125 END_IID_TABLE;
126
127 IMPLEMENT_IUNKNOWN_METHODS(wxIDropTarget)
128
129 // Name : wxIDropTarget::DragEnter
130 // Purpose : Called when the mouse enters the window (dragging something)
131 // Returns : S_OK
132 // Params : [in] IDataObject *pIDataSource : source data
133 // [in] DWORD grfKeyState : kbd & mouse state
134 // [in] POINTL pt : mouse coordinates
135 // [out]DWORD *pdwEffect : effect flag
136 // Notes :
137 STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
138 DWORD grfKeyState,
139 POINTL pt,
140 DWORD *pdwEffect)
141 {
142 wxLogDebug(wxT("IDropTarget::DragEnter"));
143
144 wxASSERT( m_pIDataObject == NULL );
145
146 if ( !m_pTarget->IsAcceptedData(pIDataSource) ) {
147 // we don't accept this kind of data
148 *pdwEffect = DROPEFFECT_NONE;
149
150 return S_OK;
151 }
152
153 // get hold of the data object
154 m_pIDataObject = pIDataSource;
155 m_pIDataObject->AddRef();
156
157 // we need client coordinates to pass to wxWin functions
158 if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
159 {
160 wxLogLastError("ScreenToClient");
161 }
162
163 // give some visual feedback
164 *pdwEffect = ConvertDragResultToEffect(
165 m_pTarget->OnEnter(pt.x, pt.y,
166 ConvertDragEffectToResult(GetDropEffect(grfKeyState))
167 )
168 );
169
170 return S_OK;
171 }
172
173 // Name : wxIDropTarget::DragOver
174 // Purpose : Indicates that the mouse was moved inside the window represented
175 // by this drop target.
176 // Returns : S_OK
177 // Params : [in] DWORD grfKeyState kbd & mouse state
178 // [in] POINTL pt mouse coordinates
179 // [out]LPDWORD pdwEffect effect flag
180 // Notes : We're called on every WM_MOUSEMOVE, so this function should be
181 // very efficient.
182 STDMETHODIMP wxIDropTarget::DragOver(DWORD grfKeyState,
183 POINTL pt,
184 LPDWORD pdwEffect)
185 {
186 // there are too many of them... wxLogDebug("IDropTarget::DragOver");
187
188 wxDragResult result;
189 if ( m_pIDataObject ) {
190 result = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
191 }
192 else {
193 // can't accept data anyhow normally
194 result = wxDragNone;
195 }
196
197 // we need client coordinates to pass to wxWin functions
198 if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
199 {
200 wxLogLastError("ScreenToClient");
201 }
202
203 *pdwEffect = ConvertDragResultToEffect(
204 m_pTarget->OnDragOver(pt.x, pt.y, result)
205 );
206
207 return S_OK;
208 }
209
210 // Name : wxIDropTarget::DragLeave
211 // Purpose : Informs the drop target that the operation has left its window.
212 // Returns : S_OK
213 // Notes : good place to do any clean-up
214 STDMETHODIMP wxIDropTarget::DragLeave()
215 {
216 wxLogDebug(wxT("IDropTarget::DragLeave"));
217
218 // remove the UI feedback
219 m_pTarget->OnLeave();
220
221 // release the held object
222 RELEASE_AND_NULL(m_pIDataObject);
223
224 return S_OK;
225 }
226
227 // Name : wxIDropTarget::Drop
228 // Purpose : Instructs the drop target to paste data that was just now
229 // dropped on it.
230 // Returns : S_OK
231 // Params : [in] IDataObject *pIDataSource the data to paste
232 // [in] DWORD grfKeyState kbd & mouse state
233 // [in] POINTL pt where the drop occured?
234 // [ouy]DWORD *pdwEffect operation effect
235 // Notes :
236 STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
237 DWORD grfKeyState,
238 POINTL pt,
239 DWORD *pdwEffect)
240 {
241 wxLogDebug(wxT("IDropTarget::Drop"));
242
243 // TODO I don't know why there is this parameter, but so far I assume
244 // that it's the same we've already got in DragEnter
245 wxASSERT( m_pIDataObject == pIDataSource );
246
247 // by default, nothing happens
248 *pdwEffect = DROPEFFECT_NONE;
249
250 // we need client coordinates to pass to wxWin functions
251 if ( !ScreenToClient(m_hwnd, (POINT *)&pt) )
252 {
253 wxLogLastError("ScreenToClient");
254 }
255
256 // first ask the drop target if it wants data
257 if ( m_pTarget->OnDrop(pt.x, pt.y) ) {
258 // it does, so give it the data source
259 m_pTarget->SetDataSource(pIDataSource);
260
261 // and now it has the data
262 wxDragResult rc = ConvertDragEffectToResult(GetDropEffect(grfKeyState));
263 rc = m_pTarget->OnData(pt.x, pt.y, rc);
264 if ( wxIsDragResultOk(rc) ) {
265 // operation succeeded
266 *pdwEffect = ConvertDragResultToEffect(rc);
267 }
268 //else: *pdwEffect is already DROPEFFECT_NONE
269 }
270 //else: OnDrop() returned FALSE, no need to copy data
271
272 // release the held object
273 RELEASE_AND_NULL(m_pIDataObject);
274
275 return S_OK;
276 }
277
278 // ============================================================================
279 // wxDropTarget implementation
280 // ============================================================================
281
282 // ----------------------------------------------------------------------------
283 // ctor/dtor
284 // ----------------------------------------------------------------------------
285
286 wxDropTarget::wxDropTarget(wxDataObject *dataObj)
287 : wxDropTargetBase(dataObj)
288 {
289 // create an IDropTarget implementation which will notify us about d&d
290 // operations.
291 m_pIDropTarget = new wxIDropTarget(this);
292 m_pIDropTarget->AddRef();
293 }
294
295 wxDropTarget::~wxDropTarget()
296 {
297 ReleaseInterface(m_pIDropTarget);
298 }
299
300 // ----------------------------------------------------------------------------
301 // [un]register drop handler
302 // ----------------------------------------------------------------------------
303
304 bool wxDropTarget::Register(WXHWND hwnd)
305 {
306 HRESULT hr = ::CoLockObjectExternal(m_pIDropTarget, TRUE, FALSE);
307 if ( FAILED(hr) ) {
308 wxLogApiError("CoLockObjectExternal", hr);
309 return FALSE;
310 }
311
312 hr = ::RegisterDragDrop((HWND) hwnd, m_pIDropTarget);
313 if ( FAILED(hr) ) {
314 ::CoLockObjectExternal(m_pIDropTarget, FALSE, FALSE);
315
316 wxLogApiError("RegisterDragDrop", hr);
317 return FALSE;
318 }
319
320 // we will need the window handle for coords transformation later
321 m_pIDropTarget->SetHwnd((HWND)hwnd);
322
323 return TRUE;
324 }
325
326 void wxDropTarget::Revoke(WXHWND hwnd)
327 {
328 HRESULT hr = ::RevokeDragDrop((HWND) hwnd);
329
330 if ( FAILED(hr) ) {
331 wxLogApiError("RevokeDragDrop", hr);
332 }
333
334 ::CoLockObjectExternal(m_pIDropTarget, FALSE, TRUE);
335
336 m_pIDropTarget->SetHwnd(0);
337 }
338
339 // ----------------------------------------------------------------------------
340 // base class pure virtuals
341 // ----------------------------------------------------------------------------
342
343 // OnDrop() is called only if we previously returned TRUE from
344 // IsAcceptedData(), so no need to check anything here
345 bool wxDropTarget::OnDrop(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
346 {
347 return TRUE;
348 }
349
350 // copy the data from the data source to the target data object
351 bool wxDropTarget::GetData()
352 {
353 wxDataFormat format = GetSupportedFormat(m_pIDataSource);
354 if ( format == wxDF_INVALID ) {
355 // this is strange because IsAcceptedData() succeeded previously!
356 wxFAIL_MSG(wxT("strange - did supported formats list change?"));
357
358 return FALSE;
359 }
360
361 STGMEDIUM stm;
362 FORMATETC fmtMemory;
363 fmtMemory.cfFormat = format;
364 fmtMemory.ptd = NULL;
365 fmtMemory.dwAspect = DVASPECT_CONTENT;
366 fmtMemory.lindex = -1;
367 fmtMemory.tymed = TYMED_HGLOBAL; // TODO to add other media
368
369 bool rc = FALSE;
370
371 HRESULT hr = m_pIDataSource->GetData(&fmtMemory, &stm);
372 if ( SUCCEEDED(hr) ) {
373 IDataObject *dataObject = m_dataObject->GetInterface();
374
375 hr = dataObject->SetData(&fmtMemory, &stm, TRUE);
376 if ( SUCCEEDED(hr) ) {
377 rc = TRUE;
378 }
379 else {
380 wxLogLastError("IDataObject::SetData()");
381 }
382 }
383 else {
384 wxLogLastError("IDataObject::GetData()");
385 }
386
387 return rc;
388 }
389
390 // ----------------------------------------------------------------------------
391 // callbacks used by wxIDropTarget
392 // ----------------------------------------------------------------------------
393
394 // we need a data source, so wxIDropTarget gives it to us using this function
395 void wxDropTarget::SetDataSource(IDataObject *pIDataSource)
396 {
397 m_pIDataSource = pIDataSource;
398 }
399
400 // determine if we accept data of this type
401 bool wxDropTarget::IsAcceptedData(IDataObject *pIDataSource) const
402 {
403 return GetSupportedFormat(pIDataSource) != wxDF_INVALID;
404 }
405
406 // ----------------------------------------------------------------------------
407 // helper functions
408 // ----------------------------------------------------------------------------
409
410 wxDataFormat wxDropTarget::GetSupportedFormat(IDataObject *pIDataSource) const
411 {
412 // this strucutre describes a data of any type (first field will be
413 // changing) being passed through global memory block.
414 static FORMATETC s_fmtMemory = {
415 0,
416 NULL,
417 DVASPECT_CONTENT,
418 -1,
419 TYMED_HGLOBAL // TODO is it worth supporting other tymeds here?
420 };
421
422 // get the list of supported formats
423 size_t nFormats = m_dataObject->GetFormatCount(wxDataObject::Set);
424 wxDataFormat format, *formats;
425 formats = nFormats == 1 ? &format : new wxDataFormat[nFormats];
426
427 m_dataObject->GetAllFormats(formats, wxDataObject::Set);
428
429 // cycle through all supported formats
430 size_t n;
431 for ( n = 0; n < nFormats; n++ ) {
432 s_fmtMemory.cfFormat = formats[n];
433
434 // NB: don't use SUCCEEDED macro here: QueryGetData returns S_FALSE
435 // for file drag and drop (format == CF_HDROP)
436 if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
437 format = formats[n];
438
439 break;
440 }
441 }
442
443 if ( formats != &format ) {
444 // free memory if we allocated it
445 delete [] formats;
446 }
447
448 return n < nFormats ? format : wxFormatInvalid;
449 }
450
451 // ----------------------------------------------------------------------------
452 // private functions
453 // ----------------------------------------------------------------------------
454
455 static wxDragResult ConvertDragEffectToResult(DWORD dwEffect)
456 {
457 switch ( dwEffect ) {
458 case DROPEFFECT_COPY:
459 return wxDragCopy;
460
461 case DROPEFFECT_MOVE:
462 return wxDragMove;
463
464 default:
465 wxFAIL_MSG(wxT("invalid value in ConvertDragEffectToResult"));
466 // fall through
467
468 case DROPEFFECT_NONE:
469 return wxDragNone;
470 }
471 }
472
473 static DWORD ConvertDragResultToEffect(wxDragResult result)
474 {
475 switch ( result ) {
476 case wxDragCopy:
477 return DROPEFFECT_COPY;
478
479 case wxDragMove:
480 return DROPEFFECT_MOVE;
481
482 default:
483 wxFAIL_MSG(wxT("invalid value in ConvertDragResultToEffect"));
484 // fall through
485
486 case wxDragNone:
487 return DROPEFFECT_NONE;
488 }
489 }
490
491 #endif
492 // wxUSE_DRAG_AND_DROP