ReactOS  0.4.13-dev-563-g0561610
CFSDropTarget.cpp
Go to the documentation of this file.
1 
2 /*
3  * file system folder drop target
4  *
5  * Copyright 1997 Marcus Meissner
6  * Copyright 1998, 1999, 2002 Juergen Schmied
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22 
23 #include <precomp.h>
24 
26 
27 /****************************************************************************
28  * BuildPathsList
29  *
30  * Builds a list of paths like the one used in SHFileOperation from a table of
31  * PIDLs relative to the given base folder
32  */
33 static WCHAR* BuildPathsList(LPCWSTR wszBasePath, int cidl, LPCITEMIDLIST *pidls)
34 {
35  WCHAR *pwszPathsList = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR) * cidl + 1);
36  WCHAR *pwszListPos = pwszPathsList;
37 
38  for (int i = 0; i < cidl; i++)
39  {
40  FileStructW* pDataW = _ILGetFileStructW(pidls[i]);
41  if (!pDataW)
42  {
43  ERR("Got garbage pidl\n");
44  continue;
45  }
46 
47  PathCombineW(pwszListPos, wszBasePath, pDataW->wszName);
48  pwszListPos += wcslen(pwszListPos) + 1;
49  }
50  *pwszListPos = 0;
51  return pwszPathsList;
52 }
53 
54 /****************************************************************************
55  * CFSDropTarget::_CopyItems
56  *
57  * copies items to this folder
58  */
60  LPCITEMIDLIST * apidl, BOOL bCopy)
61 {
62  LPWSTR pszSrcList;
63  HRESULT hr;
64  WCHAR wszTargetPath[MAX_PATH + 1];
65 
66  wcscpy(wszTargetPath, m_sPathTarget);
67  //Double NULL terminate.
68  wszTargetPath[wcslen(wszTargetPath) + 1] = '\0';
69 
70  TRACE ("(%p)->(%p,%u,%p)\n", this, pSFFrom, cidl, apidl);
71 
72  STRRET strretFrom;
73  hr = pSFFrom->GetDisplayNameOf(NULL, SHGDN_FORPARSING, &strretFrom);
75  return hr;
76 
77  pszSrcList = BuildPathsList(strretFrom.pOleStr, cidl, apidl);
78  ERR("Source file (just the first) = %s, target path = %s, bCopy: %d\n", debugstr_w(pszSrcList), debugstr_w(m_sPathTarget), bCopy);
79  CoTaskMemFree(strretFrom.pOleStr);
80  if (!pszSrcList)
81  return E_OUTOFMEMORY;
82 
83  SHFILEOPSTRUCTW op = {0};
84  op.pFrom = pszSrcList;
85  op.pTo = wszTargetPath;
86  op.hwnd = m_hwndSite;
87  op.wFunc = bCopy ? FO_COPY : FO_MOVE;
89 
90  int res = SHFileOperationW(&op);
91 
92  HeapFree(GetProcessHeap(), 0, pszSrcList);
93 
94  if (res)
95  return E_FAIL;
96  else
97  return S_OK;
98 }
99 
101  m_cfShellIDList(0),
102  m_fAcceptFmt(FALSE),
103  m_sPathTarget(NULL),
104  m_hwndSite(NULL),
105  m_grfKeyState(0)
106 {
107 }
108 
110 {
111  if (!PathTarget)
112  return E_UNEXPECTED;
113 
115  if (!m_cfShellIDList)
116  return E_FAIL;
117 
118  m_sPathTarget = (WCHAR *)SHAlloc((wcslen(PathTarget) + 1) * sizeof(WCHAR));
119  if (!m_sPathTarget)
120  return E_OUTOFMEMORY;
121 
122  wcscpy(m_sPathTarget, PathTarget);
123 
124  return S_OK;
125 }
126 
128 {
130 }
131 
132 BOOL
133 CFSDropTarget::_GetUniqueFileName(LPWSTR pwszBasePath, LPCWSTR pwszExt, LPWSTR pwszTarget, BOOL bShortcut)
134 {
135  WCHAR wszLink[40];
136 
137  if (!bShortcut)
138  {
139  if (!LoadStringW(shell32_hInstance, IDS_LNK_FILE, wszLink, _countof(wszLink)))
140  wszLink[0] = L'\0';
141  }
142 
143  if (!bShortcut)
144  swprintf(pwszTarget, L"%s%s%s", wszLink, pwszBasePath, pwszExt);
145  else
146  swprintf(pwszTarget, L"%s%s", pwszBasePath, pwszExt);
147 
148  for (UINT i = 2; PathFileExistsW(pwszTarget); ++i)
149  {
150  if (!bShortcut)
151  swprintf(pwszTarget, L"%s%s (%u)%s", wszLink, pwszBasePath, i, pwszExt);
152  else
153  swprintf(pwszTarget, L"%s (%u)%s", pwszBasePath, i, pwszExt);
154  }
155 
156  return TRUE;
157 }
158 
159 /****************************************************************************
160  * IDropTarget implementation
161  */
163 {
164  /* TODO Windows does different drop effects if dragging across drives.
165  i.e., it will copy instead of move if the directories are on different disks. */
166 
167  DWORD dwEffect = m_dwDefaultEffect;
168 
169  *pdwEffect = DROPEFFECT_NONE;
170 
171  if (m_fAcceptFmt) { /* Does our interpretation of the keystate ... */
172  *pdwEffect = KeyStateToDropEffect (dwKeyState);
173 
174  if (*pdwEffect == DROPEFFECT_NONE)
175  *pdwEffect = dwEffect;
176 
177  /* ... matches the desired effect ? */
178  if (dwEffect & *pdwEffect) {
179  return TRUE;
180  }
181  }
182  return FALSE;
183 }
184 
185 HRESULT CFSDropTarget::_GetEffectFromMenu(IDataObject *pDataObject, POINTL pt, DWORD *pdwEffect, DWORD dwAvailableEffects)
186 {
188  if (!hmenu)
189  return E_OUTOFMEMORY;
190 
192 
193  if ((dwAvailableEffects & DROPEFFECT_COPY) == 0)
195  else if ((dwAvailableEffects & DROPEFFECT_MOVE) == 0)
197  else if ((dwAvailableEffects & DROPEFFECT_LINK) == 0)
199 
200  if ((*pdwEffect & DROPEFFECT_COPY))
202  else if ((*pdwEffect & DROPEFFECT_MOVE))
204  else if ((*pdwEffect & DROPEFFECT_LINK))
206 
207  /* FIXME: We need to support shell extensions here */
208 
209  /* We shouldn't use the site window here because the menu should work even when we don't have a site */
210  HWND hwndDummy = CreateWindowEx(0,
211  WC_STATIC,
212  NULL,
214  pt.x,
215  pt.y,
216  1,
217  1,
218  NULL,
219  NULL,
220  NULL,
221  NULL);
222 
223  UINT uCommand = TrackPopupMenu(hpopupmenu,
225  pt.x, pt.y, 0, hwndDummy, NULL);
226 
227  DestroyWindow(hwndDummy);
228 
229  if (uCommand == 0)
230  return S_FALSE;
231  else if (uCommand == IDM_COPYHERE)
232  *pdwEffect = DROPEFFECT_COPY;
233  else if (uCommand == IDM_MOVEHERE)
234  *pdwEffect = DROPEFFECT_MOVE;
235  else if (uCommand == IDM_LINKHERE)
236  *pdwEffect = DROPEFFECT_LINK;
237 
238  return S_OK;
239 }
240 
242 {
243  CComPtr<IFolderView> pfv;
244  POINT ptDrag;
245  HRESULT hr = psfv->QueryInterface(IID_PPV_ARG(IFolderView, &pfv));
246  if (FAILED_UNEXPECTEDLY(hr))
247  return hr;
248 
249  hr = psfv->GetDragPoint(&ptDrag);
250  if (FAILED_UNEXPECTEDLY(hr))
251  return hr;
252 
253  PIDLIST_ABSOLUTE pidlFolder;
254  PUITEMID_CHILD *apidl;
255  UINT cidl;
256  hr = SH_GetApidlFromDataObject(pdtobj, &pidlFolder, &apidl, &cidl);
257  if (FAILED_UNEXPECTEDLY(hr))
258  return hr;
259 
260  CComHeapPtr<POINT> apt;
261  if (!apt.Allocate(cidl))
262  {
263  SHFree(pidlFolder);
264  _ILFreeaPidl(apidl, cidl);
265  return E_OUTOFMEMORY;
266  }
267 
268  for (UINT i = 0; i<cidl; i++)
269  {
270  pfv->GetItemPosition(apidl[i], &apt[i]);
271  apt[i].x += pt.x - ptDrag.x;
272  apt[i].y += pt.y - ptDrag.y;
273  }
274 
275  pfv->SelectAndPositionItems(cidl, apidl, apt, SVSI_SELECT);
276 
277  SHFree(pidlFolder);
278  _ILFreeaPidl(apidl, cidl);
279  return S_OK;
280 }
281 
283  DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
284 {
285  TRACE("(%p)->(DataObject=%p)\n", this, pDataObject);
286  FORMATETC fmt;
287  FORMATETC fmt2;
289 
290  InitFormatEtc (fmt, m_cfShellIDList, TYMED_HGLOBAL);
291  InitFormatEtc (fmt2, CF_HDROP, TYMED_HGLOBAL);
292 
293  if (SUCCEEDED(pDataObject->QueryGetData(&fmt)))
294  m_fAcceptFmt = TRUE;
295  else if (SUCCEEDED(pDataObject->QueryGetData(&fmt2)))
296  m_fAcceptFmt = TRUE;
297 
298  m_grfKeyState = dwKeyState;
300 
301  STGMEDIUM medium;
302  if (SUCCEEDED(pDataObject->GetData(&fmt2, &medium)))
303  {
304  WCHAR wstrFirstFile[MAX_PATH];
305  if (DragQueryFileW((HDROP)medium.hGlobal, 0, wstrFirstFile, _countof(wstrFirstFile)))
306  {
307  /* Check if the drive letter is different */
308  if (wstrFirstFile[0] != m_sPathTarget[0])
309  {
311  }
312  }
313  ReleaseStgMedium(&medium);
314  }
315 
316  _QueryDrop(dwKeyState, pdwEffect);
317  return S_OK;
318 }
319 
321  DWORD *pdwEffect)
322 {
323  TRACE("(%p)\n", this);
324 
325  if (!pdwEffect)
326  return E_INVALIDARG;
327 
328  m_grfKeyState = dwKeyState;
329 
330  _QueryDrop(dwKeyState, pdwEffect);
331 
332  return S_OK;
333 }
334 
336 {
337  TRACE("(%p)\n", this);
338 
340 
341  return S_OK;
342 }
343 
345  DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
346 {
347  TRACE("(%p) object dropped, effect %u\n", this, *pdwEffect);
348 
349  if (!pdwEffect)
350  return E_INVALIDARG;
351 
353 
354  DWORD dwAvailableEffects = *pdwEffect;
355 
356  _QueryDrop(dwKeyState, pdwEffect);
357 
358  TRACE("pdwEffect: 0x%x, m_dwDefaultEffect: 0x%x, dwAvailableEffects: 0x%x\n", *pdwEffect, m_dwDefaultEffect, dwAvailableEffects);
359 
361  {
362  HRESULT hr = _GetEffectFromMenu(pDataObject, pt, pdwEffect, dwAvailableEffects);
363  if (FAILED_UNEXPECTEDLY(hr) || hr == S_FALSE)
364  return hr;
365  }
366 
367  if (*pdwEffect == DROPEFFECT_MOVE && m_site)
368  {
369  CComPtr<IShellFolderView> psfv;
370  HRESULT hr = IUnknown_QueryService(m_site, SID_IFolderView, IID_PPV_ARG(IShellFolderView, &psfv));
371  if (SUCCEEDED(hr) && psfv->IsDropOnSource(this) == S_OK)
372  {
373  _RepositionItems(psfv, pDataObject, pt);
374  return S_OK;
375  }
376  }
377 
378  BOOL fIsOpAsync = FALSE;
379  CComPtr<IAsyncOperation> pAsyncOperation;
380 
381  if (SUCCEEDED(pDataObject->QueryInterface(IID_PPV_ARG(IAsyncOperation, &pAsyncOperation))))
382  {
383  if (SUCCEEDED(pAsyncOperation->GetAsyncMode(&fIsOpAsync)) && fIsOpAsync)
384  {
385  _DoDropData *data = static_cast<_DoDropData*>(HeapAlloc(GetProcessHeap(), 0, sizeof(_DoDropData)));
386  data->This = this;
387  // Need to maintain this class in case the window is closed or the class exists temporarily (when dropping onto a folder).
388  pDataObject->AddRef();
389  pAsyncOperation->StartOperation(NULL);
391  this->AddRef();
392  data->dwKeyState = dwKeyState;
393  data->pt = pt;
394  // Need to dereference as pdweffect gets freed.
395  data->pdwEffect = *pdwEffect;
397  return S_OK;
398  }
399  }
400  return this->_DoDrop(pDataObject, dwKeyState, pt, pdwEffect);
401 }
402 
403 HRESULT
404 WINAPI
406 {
407  m_site = pUnkSite;
408  return S_OK;
409 }
410 
411 HRESULT
412 WINAPI
414 {
415  if (!m_site)
416  return E_FAIL;
417 
418  return m_site->QueryInterface(riid, ppvSite);
419 }
420 
422  DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
423 {
424  TRACE("(%p) performing drop, effect %u\n", this, *pdwEffect);
425  FORMATETC fmt;
426  FORMATETC fmt2;
427  STGMEDIUM medium;
428 
429  InitFormatEtc (fmt, m_cfShellIDList, TYMED_HGLOBAL);
430  InitFormatEtc (fmt2, CF_HDROP, TYMED_HGLOBAL);
431 
432  HRESULT hr;
433  bool bCopy = TRUE;
434  bool bLinking = FALSE;
435 
436  /* Figure out what drop operation we're doing */
437  if (pdwEffect)
438  {
439  TRACE("Current drop effect flag %i\n", *pdwEffect);
440  if ((*pdwEffect & DROPEFFECT_MOVE) == DROPEFFECT_MOVE)
441  bCopy = FALSE;
442  if ((*pdwEffect & DROPEFFECT_LINK) == DROPEFFECT_LINK)
443  bLinking = TRUE;
444  }
445 
446  if (SUCCEEDED(pDataObject->QueryGetData(&fmt)))
447  {
448  hr = pDataObject->GetData(&fmt, &medium);
449  TRACE("CFSTR_SHELLIDLIST.\n");
450 
451  /* lock the handle */
452  LPIDA lpcida = (LPIDA)GlobalLock(medium.hGlobal);
453  if (!lpcida)
454  {
455  ReleaseStgMedium(&medium);
456  return E_FAIL;
457  }
458 
459  /* convert the data into pidl */
460  LPITEMIDLIST pidl;
461  LPITEMIDLIST *apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
462  if (!apidl)
463  {
464  ReleaseStgMedium(&medium);
465  return E_FAIL;
466  }
467 
468  CComPtr<IShellFolder> psfDesktop;
469  CComPtr<IShellFolder> psfFrom = NULL;
470 
471  /* Grab the desktop shell folder */
472  hr = SHGetDesktopFolder(&psfDesktop);
473  if (FAILED(hr))
474  {
475  ERR("SHGetDesktopFolder failed\n");
476  SHFree(pidl);
477  _ILFreeaPidl(apidl, lpcida->cidl);
478  ReleaseStgMedium(&medium);
479  return E_FAIL;
480  }
481 
482  /* Find source folder, this is where the clipboard data was copied from */
483  if (_ILIsDesktop(pidl))
484  {
485  /* use desktop shell folder */
486  psfFrom = psfDesktop;
487  }
488  else
489  {
490  hr = psfDesktop->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfFrom));
491  if (FAILED(hr))
492  {
493  ERR("no IShellFolder\n");
494  SHFree(pidl);
495  _ILFreeaPidl(apidl, lpcida->cidl);
496  ReleaseStgMedium(&medium);
497  return E_FAIL;
498  }
499  }
500 
501  if (bLinking)
502  {
503  WCHAR wszTargetPath[MAX_PATH];
504  WCHAR wszPath[MAX_PATH];
505  WCHAR wszTarget[MAX_PATH];
506 
507  wcscpy(wszTargetPath, m_sPathTarget);
508 
509  TRACE("target path = %s", debugstr_w(wszTargetPath));
510 
511  /* We need to create a link for each pidl in the copied items, so step through the pidls from the clipboard */
512  for (UINT i = 0; i < lpcida->cidl; i++)
513  {
514  //Find out which file we're copying
515  STRRET strFile;
516  hr = psfFrom->GetDisplayNameOf(apidl[i], SHGDN_FORPARSING, &strFile);
517  if (FAILED(hr))
518  {
519  ERR("Error source obtaining path");
520  break;
521  }
522 
523  hr = StrRetToBufW(&strFile, apidl[i], wszPath, _countof(wszPath));
524  if (FAILED(hr))
525  {
526  ERR("Error putting source path into buffer");
527  break;
528  }
529  TRACE("source path = %s", debugstr_w(wszPath));
530 
531  // Creating a buffer to hold the combined path
532  WCHAR buffer_1[MAX_PATH] = L"";
533  WCHAR *lpStr1;
534  lpStr1 = buffer_1;
535 
536  LPWSTR pwszFileName = PathFindFileNameW(wszPath);
537  LPWSTR pwszExt = PathFindExtensionW(wszPath);
538  LPWSTR placementPath = PathCombineW(lpStr1, m_sPathTarget, pwszFileName);
539  CComPtr<IPersistFile> ppf;
540 
541  //Check to see if it's already a link.
542  if (!wcsicmp(pwszExt, L".lnk"))
543  {
544  //It's a link so, we create a new one which copies the old.
545  if(!_GetUniqueFileName(placementPath, pwszExt, wszTarget, TRUE))
546  {
547  ERR("Error getting unique file name");
548  hr = E_FAIL;
549  break;
550  }
552  if (FAILED(hr)) {
553  ERR("Error constructing link from file");
554  break;
555  }
556 
557  hr = ppf->Save(wszTarget, FALSE);
558  if (FAILED(hr))
559  break;
561  }
562  else
563  {
564  //It's not a link, so build a new link using the creator class and fill it in.
565  //Create a file name for the link
566  if (!_GetUniqueFileName(placementPath, L".lnk", wszTarget, TRUE))
567  {
568  ERR("Error creating unique file name");
569  hr = E_FAIL;
570  break;
571  }
572 
573  CComPtr<IShellLinkW> pLink;
574  hr = CShellLink::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IShellLinkW, &pLink));
575  if (FAILED(hr)) {
576  ERR("Error instantiating IShellLinkW");
577  break;
578  }
579 
580  WCHAR szDirPath[MAX_PATH], *pwszFile;
581  GetFullPathName(wszPath, MAX_PATH, szDirPath, &pwszFile);
582  if (pwszFile) pwszFile[0] = 0;
583 
584  hr = pLink->SetPath(wszPath);
585  if(FAILED(hr))
586  break;
587 
588  hr = pLink->SetWorkingDirectory(szDirPath);
589  if(FAILED(hr))
590  break;
591 
592  hr = pLink->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
593  if(FAILED(hr))
594  break;
595 
596  hr = ppf->Save(wszTarget, TRUE);
597  if (FAILED(hr))
598  break;
600  }
601  }
602  }
603  else
604  {
605  hr = _CopyItems(psfFrom, lpcida->cidl, (LPCITEMIDLIST*)apidl, bCopy);
606  }
607 
608  SHFree(pidl);
609  _ILFreeaPidl(apidl, lpcida->cidl);
610  ReleaseStgMedium(&medium);
611  }
612  else if (SUCCEEDED(pDataObject->QueryGetData(&fmt2)))
613  {
614  FORMATETC fmt2;
615  InitFormatEtc (fmt2, CF_HDROP, TYMED_HGLOBAL);
616  if (SUCCEEDED(pDataObject->GetData(&fmt2, &medium)) /* && SUCCEEDED(pDataObject->GetData(&fmt2, &medium))*/)
617  {
618  WCHAR wszTargetPath[MAX_PATH + 1];
619  LPWSTR pszSrcList;
620 
621  wcscpy(wszTargetPath, m_sPathTarget);
622  //Double NULL terminate.
623  wszTargetPath[wcslen(wszTargetPath) + 1] = '\0';
624 
625  LPDROPFILES lpdf = (LPDROPFILES) GlobalLock(medium.hGlobal);
626  if (!lpdf)
627  {
628  ERR("Error locking global\n");
629  return E_FAIL;
630  }
631  pszSrcList = (LPWSTR) (((byte*) lpdf) + lpdf->pFiles);
632  ERR("Source file (just the first) = %s, target path = %s, bCopy: %d\n", debugstr_w(pszSrcList), debugstr_w(wszTargetPath), bCopy);
633 
635  ZeroMemory(&op, sizeof(op));
636  op.pFrom = pszSrcList;
637  op.pTo = wszTargetPath;
638  op.hwnd = m_hwndSite;
639  op.wFunc = bCopy ? FO_COPY : FO_MOVE;
641  hr = SHFileOperationW(&op);
642  return hr;
643  }
644  ERR("Error calling GetData\n");
645  hr = E_FAIL;
646  }
647  else
648  {
649  ERR("No viable drop format.\n");
650  hr = E_FAIL;
651  }
652  return hr;
653 }
654 
656 {
658  _DoDropData *data = static_cast<_DoDropData*>(lpParameter);
659  CComPtr<IDataObject> pDataObject;
661 
662  if (SUCCEEDED(hr))
663  {
664  CComPtr<IAsyncOperation> pAsyncOperation;
665  hr = data->This->_DoDrop(pDataObject, data->dwKeyState, data->pt, &data->pdwEffect);
666  if (SUCCEEDED(pDataObject->QueryInterface(IID_PPV_ARG(IAsyncOperation, &pAsyncOperation))))
667  {
668  pAsyncOperation->EndOperation(hr, NULL, data->pdwEffect);
669  }
670  }
671  //Release the CFSFolder and data object holds in the copying thread.
672  data->This->Release();
673  //Release the parameter from the heap.
675  CoUninitialize();
676  return 0;
677 }
678 
680 {
681  return ShellObjectCreatorInit<CFSDropTarget>(sPathTarget, riid, ppvOut);
682 }
virtual HRESULT WINAPI Drop(IDataObject *pDataObject, DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
LPWSTR m_sPathTarget
Definition: CFSDropTarget.h:34
#define WS_DISABLED
Definition: pedump.c:621
struct _DROPFILES * LPDROPFILES
#define REFIID
Definition: guiddef.h:113
#define TRUE
Definition: types.h:120
#define MF_BYCOMMAND
Definition: winuser.h:202
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:422
#define IDM_LINKHERE
Definition: shresdef.h:780
long y
Definition: polytest.cpp:48
HRESULT CFSDropTarget_CreateInstance(LPWSTR sPathTarget, REFIID riid, LPVOID *ppvOut)
virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite)
#define CFSTR_SHELLIDLIST
Definition: shlobj.h:469
CComPtr< IUnknown > m_site
Definition: CFSDropTarget.h:38
HRESULT hr
Definition: shlfolder.c:183
static HMENU hmenu
Definition: win.c:66
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
long x
Definition: polytest.cpp:48
#define InitFormatEtc(fe, cf, med)
Definition: editor.h:33
void WINAPI ReleaseStgMedium(STGMEDIUM *pmedium)
Definition: ole2.c:2036
#define pt(x, y)
Definition: drawing.c:79
#define TPM_LEFTALIGN
Definition: winuser.h:2331
WINE_DEFAULT_DEBUG_CHANNEL(shell)
REFIID riid
Definition: precomp.h:44
UINT WINAPI RegisterClipboardFormatW(_In_ LPCWSTR)
#define FO_COPY
Definition: shellapi.h:134
#define TPM_RETURNCMD
Definition: winuser.h:2341
#define _countof(array)
Definition: fontsub.cpp:30
HRESULT WINAPI StrRetToBufW(LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len)
Definition: string.c:1522
WCHAR wszName[1]
Definition: shlfolder.c:1555
ITEMID_CHILD UNALIGNED * PUITEMID_CHILD
Definition: shtypes.idl:68
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
const char * fmt
Definition: wsprintf.c:30
HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid, LPVOID *ppv)
Definition: marshal.c:2145
HRESULT _CopyItems(IShellFolder *pSFFrom, UINT cidl, LPCITEMIDLIST *apidl, BOOL bCopy)
LPWSTR pOleStr
Definition: shtypes.idl:96
#define FOF_ALLOWUNDO
Definition: shellapi.h:144
HRESULT GetData([in, unique] FORMATETC *pformatetcIn, [out] STGMEDIUM *pmedium)
#define ZeroMemory
Definition: winbase.h:1635
const GUID IID_IDataObject
#define SID_IFolderView
#define IID_PPV_ARG(Itype, ppType)
#define E_FAIL
Definition: ddrawi.h:102
HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
Definition: ordinal.c:1283
virtual HRESULT WINAPI DragOver(DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
BOOL WINAPI DestroyWindow(_In_ HWND)
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
int WINAPI SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp)
Definition: shlfileop.cpp:1782
HRESULT WINAPI IUnknown_QueryService(IUnknown *, REFGUID, REFIID, LPVOID *)
Definition: ordinal.c:1448
LPITEMIDLIST * _ILCopyCidaToaPidl(LPITEMIDLIST *pidl, const CIDA *cida)
Definition: pidl.c:2659
static DWORD WINAPI _DoDropThreadProc(LPVOID lpParameter)
const DWORD DROPEFFECT_COPY
Definition: oleidl.idl:930
#define FO_MOVE
Definition: shellapi.h:133
HRESULT GetDisplayNameOf([in] PCUITEMID_CHILD pidl, [in] SHGDNF uFlags, [out] STRRET *lpName)
#define IDM_DRAGFILE
Definition: shresdef.h:777
const DWORD DROPEFFECT_NONE
Definition: oleidl.idl:929
#define TPM_RIGHTBUTTON
Definition: winuser.h:2334
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
HINSTANCE shell32_hInstance
Definition: misc.cpp:82
#define WC_STATIC
Definition: commctrl.h:4653
unsigned int BOOL
Definition: ntddk_ex.h:94
virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite)
#define debugstr_w
Definition: kernel32.h:32
#define SS_LEFT
Definition: pedump.c:692
#define CreateWindowEx
Definition: winuser.h:5621
#define S_FALSE
Definition: winerror.h:2357
#define E_INVALIDARG
Definition: ddrawi.h:101
HRESULT SH_GetApidlFromDataObject(IDataObject *pDataObject, PIDLIST_ABSOLUTE *ppidlfolder, PUITEMID_CHILD **apidlItems, UINT *pcidl)
Definition: shlfolder.cpp:327
smooth NULL
Definition: ftsmooth.c:416
#define KeyStateToDropEffect(kst)
Definition: shell32_main.h:95
#define CF_HDROP
Definition: constants.h:410
LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
Definition: path.c:389
HRESULT _GetEffectFromMenu(IDataObject *pDataObject, POINTL pt, DWORD *pdwEffect, DWORD dwAvailableEffects)
BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
Definition: path.c:1756
static HMENU hpopupmenu
Definition: msg.c:16961
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:442
#define MK_RBUTTON
Definition: winuser.h:2322
BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
Definition: CBandSite.h:24
UINT m_cfShellIDList
Definition: CFSDropTarget.h:32
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
#define WS_OVERLAPPED
Definition: pedump.c:615
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
BOOL _QueryDrop(DWORD dwKeyState, LPDWORD pdwEffect)
BOOL WINAPI DeleteMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
#define FAILED_UNEXPECTEDLY(hr)
Definition: shellutils.h:35
#define MAX_PATH
Definition: compat.h:26
#define swprintf(buf, format,...)
Definition: sprintf.c:56
virtual HRESULT WINAPI DragLeave()
#define WINAPI
Definition: msvc.h:8
const DWORD DROPEFFECT_LINK
Definition: oleidl.idl:932
struct CIDA * LPIDA
UINT cidl
Definition: shlobj.h:491
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define TPM_NONOTIFY
Definition: winuser.h:2340
ULONG AddRef()
#define IDM_COPYHERE
Definition: shresdef.h:778
HRESULT _RepositionItems(IShellFolderView *psfv, IDataObject *pDataObject, POINTL pt)
HRESULT _DoDrop(IDataObject *pDataObject, DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
static const WCHAR L[]
Definition: oid.c:1250
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
DWORD m_dwDefaultEffect
Definition: CFSDropTarget.h:37
LPVOID lpParameter
Definition: kernel32.h:234
#define GetFullPathName
Definition: winbase.h:3635
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
Definition: changenotify.c:340
BOOL _GetUniqueFileName(LPWSTR pwszBasePath, LPCWSTR pwszExt, LPWSTR pwszTarget, BOOL bShortcut)
#define IDS_LNK_FILE
Definition: shresdef.h:165
DWORD dwKeyState
Definition: CFSDropTarget.h:77
void _ILFreeaPidl(LPITEMIDLIST *apidl, UINT cidl)
Definition: pidl.c:2621
#define wcsicmp
Definition: string.h:1152
#define SHCNF_PATHW
Definition: shlobj.h:1755
HRESULT Initialize(LPWSTR PathTarget)
#define IDM_MOVEHERE
Definition: shresdef.h:779
#define ERR(fmt,...)
Definition: debug.h:109
HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM *ppStm)
Definition: marshal.c:2101
#define S_OK
Definition: intsafe.h:59
#define WS_BORDER
Definition: pedump.c:625
static WCHAR * BuildPathsList(LPCWSTR wszBasePath, int cidl, LPCITEMIDLIST *pidls)
FileStructW * _ILGetFileStructW(LPCITEMIDLIST pidl)
Definition: pidl.c:2336
const DWORD DROPEFFECT_MOVE
Definition: oleidl.idl:931
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:1991
HRESULT QueryGetData([in, unique] FORMATETC *pformatetc)
virtual HRESULT WINAPI DragEnter(IDataObject *pDataObject, DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI SetMenuDefaultItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define E_UNEXPECTED
Definition: winerror.h:2456
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:331
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1897
GLuint res
Definition: glext.h:9613
#define TPM_LEFTBUTTON
Definition: winuser.h:2333
uint32_t * LPDWORD
Definition: typedefs.h:57
HMENU WINAPI LoadMenuW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
DWORD m_grfKeyState
Definition: CFSDropTarget.h:36
UINT op
Definition: effect.c:223
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define SHCNE_CREATE
Definition: shlobj.h:1721
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
Definition: path.c:189
BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE pfnThreadProc, VOID *pData, DWORD dwFlags, LPTHREAD_START_ROUTINE pfnCallback)
Definition: thread.c:356
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
UINT WINAPI DragQueryFileW(HDROP hDrop, UINT lFile, LPWSTR lpszwFile, UINT lLength)
Definition: shellole.c:627
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define FOF_NOCONFIRMMKDIR
Definition: shellapi.h:147
BOOL WINAPI TrackPopupMenu(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _Reserved_ int, _In_ HWND, _Reserved_ LPCRECT)
Definition: dsound.c:943
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:309
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:394
#define SUCCEEDED(hr)
Definition: intsafe.h:57
Definition: shlobj.h:490