Context Navigation

source: trunk/dll/draglist.c@ 551

Visit:

Last change on this file since 551 was 551, checked in by Gregg Young, 18 years ago
Indentation cleanup
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.2 KB

Line
1
2	/***********************************************************************
3
4	$Id: draglist.c 551 2007-02-28 01:33:51Z gyoung $
5
6	Drag drop support
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2001, 2002 Steven H.Levine
10
11	16 Oct 02 SHL DoFileDrag: don't free stack
12	26 Jul 06 SHL Check more run time errors
13
14	***********************************************************************/
15
16	#define INCL_DOS
17	#define INCL_WIN
18	#include <os2.h>
19
20	#include <stdio.h>
21	#include <stdlib.h>
22	#include <string.h>
23	#include <ctype.h>
24
25	#include "fm3dll.h"
26
27	static PSZ pszSrcFile = __FILE__;
28
29	#pragma alloc_text(DRAGLIST,DragOne,DoFileDrag,DragList,PickUp)
30
31	HWND DragOne(HWND hwndCnr, HWND hwndObj, CHAR * filename, BOOL moveok)
32	{
33
34	DRAGITEM DItem;
35	HWND hDrop = 0;
36	DRAGIMAGE fakeicon;
37	PDRAGINFO pDInfo;
38	FILESTATUS3 fs3;
39	CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
40
41	if (filename && *filename) {
42	if ((IsRoot(filename) && IsValidDrive(*filename)) \|\|
43	!DosQueryPathInfo(filename, FIL_STANDARD, &fs3, sizeof(fs3))) {
44	strcpy(szDir, filename);
45	p = szDir;
46	while (*p) {
47	if (*p == '/')
48	*p = '\\';
49	p++;
50	}
51	p = strrchr(szDir, '\\');
52	if (p) {
53	*p = 0;
54	p++;
55	strcpy(szFile, p);
56	strcat(szDir, "\\");
57	}
58	else {
59	strcpy(szFile, filename);
60	*szDir = 0;
61	}
62	memset(&fakeicon, 0, sizeof(DRAGIMAGE));
63	fakeicon.hImage = (IsRoot(filename) \|\|
64	(fs3.attrFile & FILE_DIRECTORY) != 0) ?
65	hptrDir : hptrFile;
66	memset(&DItem, 0, sizeof(DRAGITEM));
67	DItem.hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM */
68	// DItem.hwndItem = hwndCnr;
69	DItem.ulItemID = 1;
70	DItem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
71	DItem.hstrRMF = DrgAddStrHandle(DRMDRFLIST);
72	DItem.hstrContainerName = DrgAddStrHandle(szDir);
73	DItem.hstrSourceName = DrgAddStrHandle(szFile);
74	DItem.hstrTargetName = DrgAddStrHandle(szFile);
75	DItem.fsControl = 0;
76	if (IsRoot(filename) \|\| (fs3.attrFile & FILE_DIRECTORY) != 0)
77	DItem.fsControl \|= DC_CONTAINER;
78	if (IsFullName(filename) &&
79	(driveflags[toupper(*filename) - 'A'] & DRIVE_REMOVABLE))
80	DItem.fsControl \|= DC_REMOVEABLEMEDIA;
81	DItem.fsSupportedOps = DO_COPYABLE \| DO_LINKABLE;
82	if (moveok && IsFullName(filename) &&
83	!(driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
84	DItem.fsSupportedOps \|= DO_MOVEABLE;
85	if (IsRoot(filename))
86	DItem.fsSupportedOps = DO_LINKABLE;
87	fakeicon.cb = sizeof(DRAGIMAGE);
88	fakeicon.cptl = 0;
89	fakeicon.fl = DRG_ICON;
90	fakeicon.sizlStretch.cx = 32;
91	fakeicon.sizlStretch.cy = 32;
92	fakeicon.cxOffset = -16;
93	fakeicon.cyOffset = 0;
94	pDInfo = DrgAllocDraginfo(1); /* Allocate DRAGINFO */
95	if (pDInfo) {
96	if (IsFullName(filename) &&
97	(driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
98	pDInfo->usOperation = DO_COPY;
99	else
100	pDInfo->usOperation = DO_DEFAULT;
101	if (IsRoot(filename))
102	pDInfo->usOperation = DO_LINK;
103	pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
104	// pDInfo->hwndSource = hwndCnr;
105	DrgSetDragitem(pDInfo, /* Set item in DRAGINFO */
106	&DItem, /* Pointer to DRAGITEM */
107	sizeof(DRAGITEM), /* Size of DRAGITEM */
108	0); /* Index of DRAGITEM */
109	WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
110	hDrop = DrgDrag(hwndCnr, /* Initiate drag */
111	pDInfo, /* DRAGINFO structure */
112	&fakeicon, 1L, VK_ENDDRAG, /* End of drag indicator */
113	(PVOID) NULL); /* Reserved */
114
115	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO struct */
116	WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
117	}
118	}
119	}
120	return hDrop;
121	}
122
123	HWND DoFileDrag(HWND hwndCnr, HWND hwndObj, PCNRDRAGINIT pcd, CHAR * arcfile,
124	CHAR * directory, BOOL moveok)
125	{
126	/* drag files from a container */
127
128	BOOL isdir, rooting = FALSE;
129	PCNRITEM pci;
130	register CHAR *p;
131	INT attribute = CRA_CURSORED;
132	PDRAGINFO pDInfo = NULL;
133	DRAGITEM ppDItem = NULL, ppTest;
134	PCNRITEM pciRec = (PCNRITEM) pcd->pRecord;
135	HWND hDrop = 0;
136	register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
137	CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
138	DRAGIMAGE padiIcon = NULL, padiTest, diFakeIcon;
139
140	if (!pciRec && directory && *directory)
141	return DragOne(hwndCnr, hwndObj, directory, moveok);
142
143	if (!pciRec) {
144	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
145	MPFROMLONG(CMA_FIRST),
146	MPFROMSHORT(attribute));
147	if (pci && (INT) pci > -1) {
148	if (pci->rc.flRecordAttr & CRA_SELECTED) {
149	attribute = CRA_SELECTED;
150	pci =
151	WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
152	MPFROMSHORT(attribute));
153	}
154	}
155	}
156	else {
157	pci = pciRec;
158	attribute = (pci->rc.flRecordAttr & CRA_SELECTED) ? CRA_SELECTED : 0;
159	if (attribute) {
160	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
161	MPFROMSHORT(attribute));
162	}
163	}
164
165	Select = 0L;
166	while (pci && (INT) pci > -1) {
167	if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
168	if (IsRoot(pci->szFileName) && !IsValidDrive(*pci->szFileName))
169	goto Continuing;
170	if (!arcfile) {
171	strcpy(szBuffer, pci->szFileName);
172	p = strrchr(szBuffer, '\\');
173	if (p) {
174	p++;
175	strcpy(szFile, p);
176	*p = 0;
177	}
178	else
179	goto Continuing;
180	}
181	else
182	strcpy(szFile, pci->szFileName);
183	}
184	if (!arcfile) {
185	// Filesystem object
186	isdir = ((pci->attrFile & FILE_DIRECTORY) != 0);
187	if (ulNumfiles + 2L > numdragalloc) {
188	if (!padiIcon) {
189	padiTest =
190	xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
191	pszSrcFile, __LINE__);
192	if (padiTest)
193	padiIcon = padiTest;
194	else
195	break;
196	}
197	else if (!ulNumIcon) {
198	padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
199	padiIcon[ulNumfiles].cptl = 0;
200	padiIcon[ulNumfiles].hImage = hptrLast;
201	padiIcon[ulNumfiles].fl = DRG_ICON;
202	padiIcon[ulNumfiles].sizlStretch.cx = 32;
203	padiIcon[ulNumfiles].sizlStretch.cy = 32;
204	padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
205	padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
206	ulNumIcon = ulNumfiles + 1;
207	}
208	ppTest =
209	xrealloc(ppDItem, sizeof(DRAGITEM ) (numdragalloc + 4L),
210	pszSrcFile, __LINE__);
211	if (ppTest) {
212	ppDItem = ppTest;
213	numdragalloc += 4L;
214	}
215	else
216	break;
217	}
218	ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
219	if (ppDItem[ulNumfiles]) {
220	if (!ulNumIcon) {
221	padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
222	padiIcon[ulNumfiles].cptl = 0;
223	padiIcon[ulNumfiles].hImage = pci->rc.hptrIcon;
224	if (!padiIcon[ulNumfiles].hImage)
225	padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
226	padiIcon[ulNumfiles].fl = DRG_ICON;
227	padiIcon[ulNumfiles].sizlStretch.cx = 32;
228	padiIcon[ulNumfiles].sizlStretch.cy = 32;
229	padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
230	padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
231	}
232	memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
233	ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM */
234	ppDItem[ulNumfiles]->hwndItem = hwndCnr;
235	ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
236	ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
237	ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
238	ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
239	ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
240	ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
241	ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
242	if (IsFullName(pci->szFileName) &&
243	(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
244	ppDItem[ulNumfiles]->fsControl \|= DC_REMOVEABLEMEDIA;
245	ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE \| DO_LINKABLE;
246	if (moveok && IsFullName(pci->szFileName) &&
247	!(driveflags[toupper(*pci->szFileName) - 'A'] &
248	DRIVE_NOTWRITEABLE))
249	ppDItem[ulNumfiles]->fsSupportedOps \|= DO_MOVEABLE;
250	if (IsRoot(pci->szFileName)) {
251	ppDItem[ulNumfiles]->fsSupportedOps = DO_LINKABLE;
252	rooting = TRUE;
253	}
254	ulNumfiles++;
255	ppDItem[ulNumfiles] = NULL;
256	}
257	else
258	break;
259	}
260	else {
261	// Archive object
262	if (ulNumfiles + 3L > numdragalloc) {
263	ppTest =
264	xrealloc(ppDItem, sizeof(DRAGITEM ) (numdragalloc + 5L),
265	pszSrcFile, __LINE__);
266	if (!ppTest)
267	break;
268	else {
269	ppDItem = ppTest;
270	numdragalloc += 5L;
271	}
272	}
273	ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
274	if (!ppDItem[ulNumfiles])
275	break;
276	else {
277	diFakeIcon.hImage = hptrFile;
278	memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
279	ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM */
280	ppDItem[ulNumfiles]->hwndItem = hwndCnr;
281	ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
282	ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
283	ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFOS2FILE);
284	ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
285	ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
286	ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
287	ppDItem[ulNumfiles]->fsControl = DC_PREPARE;
288	if (IsFullName(arcfile) &&
289	(driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
290	ppDItem[ulNumfiles]->fsControl \|= DC_REMOVEABLEMEDIA;
291	ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
292	ulNumfiles++;
293	ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
294	if (ppDItem[ulNumfiles]) {
295	diFakeIcon.hImage = hptrFile;
296	memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
297	ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM */
298	ppDItem[ulNumfiles]->hwndItem = hwndCnr;
299	ppDItem[ulNumfiles]->ulItemID = Select++;
300	ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
301	ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFFM2ARC);
302	ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
303	ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
304	ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
305	ppDItem[ulNumfiles]->fsControl = 0;
306	if (IsFullName(arcfile) &&
307	(driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
308	ppDItem[ulNumfiles]->fsControl \|= DC_REMOVEABLEMEDIA;
309	ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
310	ulNumfiles++;
311	}
312	ppDItem[ulNumfiles] = NULL;
313	}
314	}
315	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
316	MPFROM2SHORT(TRUE, CRA_SOURCE));
317
318	Continuing:
319
320	if (!attribute)
321	break;
322	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
323	MPFROMSHORT(attribute));
324	} // while
325
326	if (ulNumfiles) {
327	pDInfo = DrgAllocDraginfo(ulNumfiles); /* Allocate DRAGINFO */
328	if (pDInfo) {
329	if ((arcfile && *arcfile) \|\| (IsFullName(szBuffer) &&
330	(driveflags[toupper(*szBuffer) - 'A'] &
331	DRIVE_NOTWRITEABLE)))
332	pDInfo->usOperation = DO_COPY;
333	else
334	pDInfo->usOperation = DO_DEFAULT;
335	if ((!arcfile \|\| !*arcfile) && rooting)
336	pDInfo->usOperation = DO_LINK;
337	pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
338	// pDInfo->hwndSource = hwndCnr;
339	for (Select = 0L; Select < ulNumfiles; Select++) {
340	DrgSetDragitem(pDInfo, /* Set item in DRAGINFO */
341	ppDItem[Select], /* Pointer to DRAGITEM */
342	sizeof(DRAGITEM), /* Size of DRAGITEM */
343	Select); /* Index of DRAGITEM */
344	free(ppDItem[Select]);
345	}
346	#ifdef __DEBUG_ALLOC__
347	_heap_check();
348	#endif
349	free(ppDItem);
350	ppDItem = NULL;
351	DosPostEventSem(CompactSem);
352
353	if (arcfile) {
354	diFakeIcon.cb = sizeof(DRAGIMAGE);
355	diFakeIcon.cptl = 0;
356	if (ulNumfiles > 1)
357	diFakeIcon.hImage = hptrFile;
358	diFakeIcon.fl = DRG_ICON;
359	diFakeIcon.sizlStretch.cx = 32;
360	diFakeIcon.sizlStretch.cy = 32;
361	diFakeIcon.cxOffset = -16;
362	diFakeIcon.cyOffset = 0;
363	padiIcon = &diFakeIcon;
364	}
365	if (!arcfile) {
366	if (!ulNumIcon)
367	ulNumIcon = ulNumfiles;
368	}
369	else
370	ulNumIcon = 1L;
371
372	WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
373	hDrop = DrgDrag(hwndCnr, /* Initiate drag */
374	pDInfo, /* DRAGINFO structure */
375	padiIcon, ulNumIcon, VK_ENDDRAG, /* End of drag indicator */
376	(PVOID) NULL); /* Reserved */
377
378	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO struct */
379	if (padiIcon && padiIcon != &diFakeIcon)
380	free(padiIcon);
381	padiIcon = NULL;
382	WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
383	DosPostEventSem(CompactSem);
384	}
385	}
386	if (ppDItem)
387	free(ppDItem);
388	if (padiIcon && padiIcon != &diFakeIcon)
389	free(padiIcon);
390	MarkAll(hwndCnr, TRUE, FALSE, TRUE);
391	return hDrop;
392	}
393
394	HWND DragList(HWND hwnd, HWND hwndObj, CHAR ** list, BOOL moveok)
395	{
396
397	/* drag a linked list of files */
398
399	BOOL isdir;
400	register CHAR *p;
401	PDRAGINFO pDInfo = NULL;
402	DRAGITEM ppDItem = NULL, ppTest;
403	HWND hDrop = (HWND) 0;
404	register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
405	CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
406	DRAGIMAGE padiIcon = NULL, padiTest;
407	FILESTATUS3 fs3;
408
409	if (!list \|\| !list[0])
410	return hDrop;
411	for (Select = 0; list[Select]; Select++) {
412	if ((!IsRoot(list[Select]) \|\| !IsValidDrive(*list[Select])) &&
413	DosQueryPathInfo(list[Select], FIL_STANDARD, &fs3, sizeof(fs3)))
414	continue;
415	strcpy(szBuffer, list[Select]);
416	p = strrchr(szBuffer, '\\');
417	if (p) {
418	p++;
419	strcpy(szFile, p);
420	*p = 0;
421	}
422	else
423	continue;
424	if (*szFile) {
425	isdir = (IsRoot(list[Select])) ? TRUE :
426	((fs3.attrFile & FILE_DIRECTORY) != 0);
427	if (ulNumfiles + 2L > numdragalloc) {
428	if (!padiIcon) {
429	padiTest =
430	xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
431	pszSrcFile, __LINE__);
432	if (!padiTest)
433	break;
434	else
435	padiIcon = padiTest;
436	}
437	else if (!ulNumIcon) {
438	padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
439	padiIcon[ulNumfiles].cptl = 0;
440	padiIcon[ulNumfiles].hImage = hptrLast;
441	padiIcon[ulNumfiles].fl = DRG_ICON;
442	padiIcon[ulNumfiles].sizlStretch.cx = 32;
443	padiIcon[ulNumfiles].sizlStretch.cy = 32;
444	padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
445	padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
446	ulNumIcon = ulNumfiles + 1;
447	}
448	ppTest =
449	xrealloc(ppDItem, sizeof(DRAGITEM ) (numdragalloc + 4L),
450	pszSrcFile, __LINE__);
451	if (!ppTest)
452	break;
453	else {
454	ppDItem = ppTest;
455	numdragalloc += 4L;
456	}
457	}
458	ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
459	if (!ppDItem[ulNumfiles])
460	break;
461	else {
462	if (!ulNumIcon) {
463	padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
464	padiIcon[ulNumfiles].cptl = 0;
465	padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
466	padiIcon[ulNumfiles].fl = DRG_ICON;
467	padiIcon[ulNumfiles].sizlStretch.cx = 32;
468	padiIcon[ulNumfiles].sizlStretch.cy = 32;
469	padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
470	padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
471	}
472	memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
473	ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwnd; /* Initialize DRAGITEM */
474	// ppDItem[ulNumfiles]->hwndItem = hwnd;
475	ppDItem[ulNumfiles]->ulItemID = (ULONG) Select;
476	ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
477	ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
478	ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
479	ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
480	ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
481	ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
482	if (IsFullName(list[Select]) &&
483	(driveflags[toupper(*list[Select]) - 'A'] & DRIVE_REMOVABLE))
484	ppDItem[ulNumfiles]->fsControl \|= DC_REMOVEABLEMEDIA;
485	ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE \| DO_LINKABLE;
486	if (moveok && IsFullName(list[Select]) &&
487	!(driveflags[toupper(*list[Select]) - 'A'] & DRIVE_NOTWRITEABLE))
488	ppDItem[ulNumfiles]->fsSupportedOps \|= DO_MOVEABLE;
489	if (IsRoot(list[Select]))
490	ppDItem[ulNumfiles]->fsControl = DO_LINKABLE;
491	ulNumfiles++;
492	ppDItem[ulNumfiles] = NULL;
493	}
494	}
495	} // for
496
497	if (ulNumfiles) {
498	pDInfo = DrgAllocDraginfo(ulNumfiles); /* Allocate DRAGINFO */
499	if (pDInfo) {
500	if ((IsFullName(szBuffer) &&
501	(driveflags[toupper(*szBuffer) - 'A'] & DRIVE_NOTWRITEABLE)))
502	pDInfo->usOperation = DO_COPY;
503	else
504	pDInfo->usOperation = DO_DEFAULT;
505	if (IsRoot(list[0]))
506	pDInfo->usOperation = DO_LINK;
507	pDInfo->hwndSource = (hwndObj) ? hwndObj : hwnd;
508	// pDInfo->hwndSource = hwnd;
509	for (Select = 0L; Select < ulNumfiles; Select++) {
510	DrgSetDragitem(pDInfo, /* Set item in DRAGINFO */
511	ppDItem[Select], /* Pointer to DRAGITEM */
512	sizeof(DRAGITEM), /* Size of DRAGITEM */
513	Select); /* Index of DRAGITEM */
514	free(ppDItem[Select]);
515	} // for
516	#ifdef __DEBUG_ALLOC__
517	_heap_check();
518	#endif
519	free(ppDItem);
520	ppDItem = NULL;
521	DosPostEventSem(CompactSem);
522
523	if (!ulNumIcon)
524	ulNumIcon = ulNumfiles;
525
526	WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
527	hDrop = DrgDrag(hwnd, /* Initiate drag */
528	pDInfo, /* DRAGINFO structure */
529	padiIcon, ulNumIcon, VK_ENDDRAG, /* End of drag indicator */
530	(PVOID) NULL); /* Reserved */
531
532	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO struct */
533	free(padiIcon);
534	padiIcon = NULL;
535	WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
536	DosPostEventSem(CompactSem);
537	}
538	}
539	if (ppDItem)
540	free(ppDItem);
541	if (padiIcon)
542	free(padiIcon);
543	return hDrop;
544	}
545
546	#ifdef NEVER
547
548	BOOL PickUp(HWND hwndCnr, HWND hwndObj, PCNRDRAGINIT pcd)
549	{
550
551	PCNRITEM pci;
552	BOOL loop = TRUE;
553	PDRAGINFO pdinfoOld = NULL, pdinfoCurrent = NULL;
554	ULONG cditem = 0;
555	DRAGITEM ditem;
556	DRAGIMAGE diFakeIcon;
557	CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
558
559	pci = (PCNRITEM) pcd->pRecord;
560	if (pci && (INT) pci != -1) {
561	if (pci->rc.flRecordAttr & CRA_SELECTED) {
562	loop = TRUE;
563	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
564	MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_SELECTED));
565	}
566	while (pci && (INT) pci != -1 && *pci->szFileName) {
567	if (pdinfoOld \|\| DrgQueryDragStatus() & DGS_LAZYDRAGINPROGRESS) {
568	if (!pdinfoOld)
569	pdinfoOld = DrgQueryDraginfoPtr(NULL);
570	if (pdinfoOld) {
571	cditem = pdinfoOld->cditem + 1;
572	pdinfoCurrent = DrgReallocDraginfo(pdinfoOld, cditem);
573	pdinfoOld = pdinfoCurrent;
574	}
575	}
576	else
577	pdinfoCurrent = pdinfoOld = DrgAllocDraginfo(1);
578	if (pdinfoCurrent) {
579	strcpy(szDir, pci->szFileName);
580	p = szDir;
581	while (*p) {
582	if (*p == '/')
583	*p = '\\';
584	p++;
585	}
586	p = strrchr(szDir, '\\');
587	if (p) {
588	*p = 0;
589	p++;
590	strcpy(szFile, p);
591	strcat(szDir, "\\");
592	}
593	else {
594	strcpy(szFile, pci->szFileName);
595	*szDir = 0;
596	}
597	ditem.ulItemID = (ULONG) pci;
598	ditem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;
599	ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
600	ditem.hstrRMF = DrgAddStrHandle(DRMDRFLIST);
601	ditem.hstrContainerName = DrgAddStrHandle(szDir);
602	ditem.hstrSourceName = DrgAddStrHandle(szFile);
603	ditem.hstrTargetName = DrgAddStrHandle(szFile);
604	ditem.fsControl = 0;
605	if (IsRoot(pci->szFileName) \|\| (pci->attrFile & FILE_DIRECTORY) != 0)
606	ditem.fsControl \|= DC_CONTAINER;
607	if (IsFullName(pci->szFileName) &&
608	(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
609	ditem.fsControl \|= DC_REMOVEABLEMEDIA;
610	ditem.fsSupportedOps = DO_COPYABLE \| DO_LINKABLE;
611	if (IsFullName(pci->szFileName) &&
612	!(driveflags[toupper(*pci->szFileName) - 'A'] &
613	DRIVE_NOTWRITEABLE))
614	ditem.fsSupportedOps \|= DO_MOVEABLE;
615	if (IsRoot(pci->szFileName))
616	ditem.fsSupportedOps = DO_LINKABLE;
617	memset(&diFakeIcon, 0, sizeof(DRAGIMAGE));
618	diFakeIcon.hImage = pci->rc.hptrIcon;
619	diFakeIcon.cb = sizeof(DRAGIMAGE);
620	diFakeIcon.cptl = 0;
621	diFakeIcon.fl = DRG_ICON;
622	diFakeIcon.sizlStretch.cx = 32;
623	diFakeIcon.sizlStretch.cy = 32;
624	diFakeIcon.cxOffset = -16;
625	diFakeIcon.cyOffset = 0;
626	if (IsFullName(pci->szFileName) &&
627	(driveflags[toupper(*pci->szFileName) - 'A'] &
628	DRIVE_NOTWRITEABLE))
629	pdinfoCurrent->usOperation = DO_COPY;
630	else
631	pdinfoCurrent->usOperation = DO_DEFAULT;
632	if (IsRoot(pci->szFileName))
633	pdinfoCurrent->usOperation = DO_LINK;
634	pdinfoCurrent->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
635	DrgSetDragitem(pdinfoCurrent, &ditem, sizeof(DRAGITEM), cditem);
636	}
637	if (!loop)
638	break;
639	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
640	MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
641	}
642	if (pdinfoCurrent)
643	return DrgLazyDrag(hwndCnr, pdinfoCurrent, &diFakeIcon, 1, NULL);
644	}
645	return FALSE;
646	}
647
648	#endif // NEVER

Note: See TracBrowser for help on using the repository browser.

Download in other formats: