Context Navigation

source: trunk/dll/draglist.c@ 603

Visit:

Last change on this file since 603 was 603, checked in by Gregg Young, 18 years ago
Work around for PM drag/drop limit; more drag/drop error checking
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.2 KB

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

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

Download in other formats: