source: trunk/dll/droplist.c@ 135

Last change on this file since 135 was 51, checked in by root, 23 years ago

Standardize EA match
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.7 KB
Line 
1
2/***********************************************************************
3
4 $Id: droplist.c 51 2003-02-12 20:22:14Z root $
5
6 Fill Directory Tree Containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2003 Steven H.Levine
10
11 Revisions 22 Nov 02 SHL - Baseline
12 08 Feb 03 SHL - DropHelp: calc EA size consistently
13
14***********************************************************************/
15
16
17#define INCL_DOS
18#define INCL_WIN
19
20#include <os2.h>
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <ctype.h>
25#include "fm3dll.h"
26#include "fm3str.h"
27
28#pragma alloc_text(DROPLIST,DoFileDrop,FullDrgName,TwoDrgNames,GetOneDrop)
29
30
31BOOL TwoDrgNames (PDRAGITEM pDItem,CHAR *buffer1,ULONG buflen1,
32 char *buffer2,ULONG buflen2) {
33
34 /*
35 * Gets archive name from directory field, file name from file field
36 * Returns FALSE on error, TRUE on success.
37 */
38
39 register ULONG len;
40 BOOL ret = FALSE;
41
42 if(pDItem && buffer2 && buflen2) { /* else error calling function */
43 if(buffer1 && buflen1) /* zero buffers */
44 *buffer1 = 0;
45 *buffer2 = 0;
46
47 if(buffer1 && buflen1) {
48 len = DrgQueryStrName(pDItem->hstrContainerName,
49 buflen1,buffer1);
50 buffer1[len] = 0;
51 if(len) { /* be sure we get full pathname of arc file */
52
53 char szTemp[CCHMAXPATH + 2];
54
55 if(!DosQueryPathInfo(buffer1,
56 FIL_QUERYFULLNAME,
57 szTemp,
58 sizeof(szTemp))) {
59 strncpy(buffer1,
60 szTemp,
61 buflen1);
62 buffer1[buflen1 - 1] = 0;
63 }
64 }
65 { /* be sure that file/directory is accessible */
66 FILESTATUS3 fsa3;
67
68 DosError(FERR_DISABLEHARDERR);
69 if(DosQueryPathInfo(buffer1,
70 FIL_STANDARD,
71 &fsa3,
72 sizeof(fsa3)) ||
73 (fsa3.attrFile & FILE_DIRECTORY) != 0) {
74 *buffer1 = 0;
75 return ret;
76 }
77 }
78 }
79
80 len = DrgQueryStrName(pDItem->hstrSourceName,
81 buflen2,
82 buffer2);
83 buffer2[len] = 0;
84 if(len)
85 ret = TRUE;
86 }
87 return ret;
88}
89
90
91BOOL FullDrgName (PDRAGITEM pDItem,CHAR *buffer,ULONG buflen) {
92
93 /*
94 * Gets full name of file from a dragged item.
95 * Returns FALSE on error, TRUE on success.
96 */
97
98 register ULONG len,blen;
99 BOOL ret = FALSE;
100
101 if(pDItem && buffer && buflen) { /* else error calling function */
102 *buffer = 0; /* zero buffer */
103
104 blen = DrgQueryStrName(pDItem->hstrContainerName,
105 buflen,buffer);
106 if(blen) {
107 if(*(buffer + (blen - 1)) != '\\') {
108 *(buffer + blen) = '\\';
109 blen++;
110 }
111 }
112 buffer[blen] = 0;
113 len = DrgQueryStrName(pDItem->hstrSourceName,
114 buflen - blen,buffer + blen);
115 buffer[blen + len] = 0;
116 { /* be sure we get full pathname of file/directory */
117 char szTemp[CCHMAXPATH + 2];
118
119 if(!DosQueryPathInfo(buffer,
120 FIL_QUERYFULLNAME,
121 szTemp,
122 sizeof(szTemp))) {
123 strncpy(buffer,
124 szTemp,
125 buflen);
126 buffer[buflen - 1] = 0;
127 }
128 }
129 { /* be sure that file/directory is accessible */
130 FILESTATUS3 fsa3;
131
132 if(!DosQueryPathInfo(buffer,
133 FIL_STANDARD,
134 &fsa3,
135 sizeof(fsa3)))
136 ret = TRUE;
137 else
138 *buffer = 0;
139 }
140 }
141 return ret;
142}
143
144
145BOOL GetOneDrop (MPARAM mp1,MPARAM mp2,char *buffer,ULONG buflen) {
146
147 PDRAGITEM pDItem; /* DRAGITEM struct ptr */
148 PDRAGINFO pDInfo; /* DRAGINFO struct ptr */
149 ULONG numitems;
150 register ULONG x;
151 BOOL ret = FALSE;
152
153 if(buffer && buflen)
154 *buffer = 0; /* zero buffer field */
155
156 pDInfo = (PDRAGINFO)mp1; /* Get DRAGINFO pointer */
157 if(pDInfo) {
158 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
159 numitems = DrgQueryDragitemCount(pDInfo);
160 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
161 0); /* Index to DRAGITEM */
162 if(buflen && buffer) {
163 if(DrgVerifyRMF(pDItem, /* Check valid rendering */
164 DRM_OS2FILE, /* mechanisms and data */
165 NULL) &&
166 !(pDItem->fsControl & DC_PREPARE))
167 ret = FullDrgName(pDItem,buffer,buflen);
168 }
169 /* note: targetfail is returned to source for all items */
170 for(x = 0;x < numitems;x++) {
171 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
172 x); /* Index to DRAGITEM */
173 DrgSendTransferMsg(pDInfo->hwndSource,DM_ENDCONVERSATION,
174 MPFROMLONG(pDItem->ulItemID),
175 MPFROMLONG(DMFL_TARGETFAIL));
176 }
177 DrgDeleteDraginfoStrHandles(pDInfo);
178 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
179 }
180
181 return ret;
182}
183
184
185BOOL AcceptOneDrop (MPARAM mp1,MPARAM mp2) {
186
187 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
188 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
189 BOOL ret = FALSE;
190
191 pDInfo = (PDRAGINFO)mp1; /* Get DRAGINFO pointer */
192 if(pDInfo) {
193 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
194 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
195 0); /* Index to DRAGITEM */
196 if(DrgVerifyRMF(pDItem, /* Check valid rendering */
197 DRM_OS2FILE, /* mechanisms and data */
198 NULL)) /* formats */
199 ret = TRUE;
200 DrgFreeDraginfo(pDInfo);
201 }
202 return ret;
203}
204
205
206ULONG FreeDrop (MPARAM mp1,MPARAM mp2) {
207
208 PDRAGINFO pDInfo;
209 ULONG numitems;
210
211 pDInfo = mp1;
212 if(pDInfo) {
213 DrgAccessDraginfo(pDInfo);
214 numitems = DrgQueryDragitemCount(pDInfo);
215 DrgDeleteDraginfoStrHandles(pDInfo);
216 DrgFreeDraginfo(pDInfo);
217 }
218 return numitems;
219}
220
221
222void DropHelp (MPARAM mp1,MPARAM mp2,HWND hwnd,char *text) {
223
224 ULONG numitems;
225
226 numitems = FreeDrop(mp1,mp2);
227 saymsg(MB_ENTER | MB_ICONASTERISK,
228 hwnd,
229 GetPString(IDS_FM2DROPHELPTEXT),
230 text,
231 numitems,
232 numitems);
233}
234
235
236LISTINFO * DoFileDrop (HWND hwndCnr, CHAR *directory, BOOL arcfilesok,
237 MPARAM mp1, MPARAM mp2) {
238
239 /* builds a list from the dropped files */
240
241 BOOL isArc = FALSE,arctest = FALSE;
242 PDRAGITEM pDItem;
243 PDRAGINFO pDInfo;
244 PCNRITEM pci;
245 CHAR szFrom[CCHMAXPATH + 1],
246 szArc[CCHMAXPATH + 1];
247 register CHAR **files = NULL;
248 INT numfiles = 0,numalloc = 0;
249 register ULONG curitem = 0L,numitems,*cbFile = NULL,*ulitemID = NULL;
250 LISTINFO *li = NULL;
251 ARC_TYPE *arcinfo = NULL;
252 USHORT Operation;
253
254 *szArc = 0;
255 pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
256 pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
257 if(!pDInfo)
258 return NULL;
259 DrgAccessDraginfo(pDInfo);
260 Operation = pDInfo->usOperation;
261 pDItem = DrgQueryDragitemPtr(pDInfo,0L);
262 if(Operation == DO_MOVE &&
263 !(pDItem->fsSupportedOps & DO_MOVEABLE)) {
264 saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"forcing DO_COPY"); // SHL
265 DosBeep(50,100);
266 Operation = DO_COPY;
267 }
268 numitems = DrgQueryDragitemCount(pDInfo);
269 while(curitem < numitems) {
270 pDItem = DrgQueryDragitemPtr(pDInfo,
271 curitem);
272 if(!pDItem)
273 break;
274
275 /* ambiguous drop request -- see what's allowed */
276 if(Operation == DO_DEFAULT || Operation >= DO_UNKNOWN) {
277 if(pDItem->fsSupportedOps & DO_COPYABLE)
278 Operation = DO_COPY;
279 else if(pDItem->fsSupportedOps & DO_MOVEABLE)
280 Operation = DO_MOVE;
281 else if(pDItem->fsSupportedOps & DO_LINKABLE)
282 Operation = DO_LINK;
283 }
284 else { /* ignore object if selected command not allowed for it */
285 switch(Operation) {
286 case DO_MOVE:
287 if(pDItem->fsSupportedOps & DO_MOVEABLE)
288 goto Okay;
289 break;
290 case DO_COPY:
291 if(pDItem->fsSupportedOps & DO_COPYABLE)
292 goto Okay;
293 break;
294 case DO_LINK:
295 if(pDItem->fsSupportedOps & DO_LINKABLE)
296 goto Okay;
297 break;
298 }
299 DrgSendTransferMsg(pDItem->hwndItem,
300 DM_ENDCONVERSATION,
301 MPFROMLONG(pDItem->ulItemID),
302 MPFROMLONG(DMFL_TARGETFAIL));
303 curitem++;
304 continue;
305 }
306
307Okay:
308
309 if(DrgVerifyRMF(pDItem,
310 DRM_OS2FILE,
311 NULL) ||
312 (arcfilesok &&
313 ((arctest = DrgVerifyRMF(pDItem,
314 DRM_FM2ARCMEMBER,
315 DRF_FM2ARCHIVE)) != FALSE))) {
316 if(pDItem->fsControl & DC_PREPARE) {
317 DrgSendTransferMsg(pDItem->hwndItem,
318 DM_ENDCONVERSATION,
319 MPFROMLONG(pDItem->ulItemID),
320 MPFROMLONG(DMFL_TARGETFAIL));
321 curitem++;
322 continue;
323 }
324
325 if(arctest ||
326 isArc) {
327 if(!isArc) {
328 if(TwoDrgNames(pDItem,
329 szArc,
330 sizeof(szArc),
331 szFrom,
332 sizeof(szFrom)) &&
333 *szArc &&
334 *szFrom) {
335 isArc = TRUE;
336 arcinfo = find_type(szArc,arcsighead);
337 }
338 if(!arcinfo ||
339 !arcinfo->extract ||
340 !*arcinfo->extract) {
341 *szArc = *szFrom = 0;
342 isArc = FALSE;
343 }
344 }
345 else
346 TwoDrgNames(pDItem,
347 NULL,
348 0,
349 szFrom,
350 sizeof(szFrom));
351 }
352 else
353 FullDrgName(pDItem,
354 szFrom,
355 sizeof(szFrom));
356
357 if(!*szFrom) {
358 DrgSendTransferMsg(pDItem->hwndItem,
359 DM_ENDCONVERSATION,
360 MPFROMLONG(pDItem->ulItemID),
361 MPFROMLONG(DMFL_TARGETFAIL));
362 curitem++;
363 continue;
364 }
365
366 if(numfiles + 2 > numalloc) {
367
368 CHAR **test;
369 ULONG *ltest;
370
371 numalloc += 12;
372 test = realloc(files,numalloc * sizeof(CHAR *));
373 if(!test)
374 goto AbortDrop;
375 files = test;
376 ltest = realloc(cbFile,numalloc * sizeof(ULONG));
377 if(!ltest)
378 goto AbortDrop;
379 cbFile = ltest;
380 ltest = realloc(ulitemID,numalloc * sizeof(ULONG));
381 if(!ltest)
382 goto AbortDrop;
383 ulitemID = ltest;
384 }
385 cbFile[numfiles] = 0;
386 if(!isArc) {
387
388 FILESTATUS4 fsa4;
389
390 if(!DosQueryPathInfo(szFrom,
391 FIL_QUERYEASIZE,
392 &fsa4,
393 sizeof(fsa4)))
394 cbFile[numfiles] = fsa4.cbFile + CBLIST_TO_EASIZE(fsa4.cbList);
395 }
396 ulitemID[numfiles] = pDItem->ulItemID;
397 files[numfiles] = strdup(szFrom);
398 files[numfiles + 1] = NULL;
399 if(!files[numfiles])
400 goto AbortDrop;
401 numfiles++;
402 DrgSendTransferMsg(pDItem->hwndItem,
403 DM_ENDCONVERSATION,
404 MPFROMLONG(pDItem->ulItemID),
405 MPFROMLONG(DMFL_TARGETSUCCESSFUL));
406 }
407 else
408 DrgSendTransferMsg(pDItem->hwndItem,
409 DM_ENDCONVERSATION,
410 MPFROMLONG(pDItem->ulItemID),
411 MPFROMLONG(DMFL_TARGETFAIL));
412 curitem++;
413 }
414
415AbortDrop:
416
417 if(files &&
418 numfiles &&
419 files[0] &&
420 cbFile &&
421 ulitemID) {
422 li = malloc(sizeof(LISTINFO));
423 if(li) {
424 memset(li,0,sizeof(LISTINFO));
425 li->type = Operation;
426 li->hwnd = hwndCnr;
427 li->list = files;
428 li->cbFile = cbFile;
429 li->ulitemID = ulitemID;
430 li->hwndS = pDInfo->hwndSource;
431 if(!pci &&
432 directory)
433 strcpy(li->targetpath,directory);
434 else if(pci)
435 strcpy(li->targetpath,pci->szFileName);
436 if(isArc) {
437 strcpy(li->arcname,szArc);
438 li->info = arcinfo;
439 }
440 SortList(li);
441 }
442 else {
443 if(cbFile)
444 free(cbFile);
445 if(ulitemID)
446 free(ulitemID);
447 if(files)
448 FreeList(files);
449 }
450 }
451 else {
452 if(cbFile)
453 free(cbFile);
454 if(ulitemID)
455 free(ulitemID);
456 if(files)
457 FreeList(files);
458 }
459 DrgDeleteDraginfoStrHandles(pDInfo);
460 DrgFreeDraginfo(pDInfo);
461 return li;
462}
463
Note: See TracBrowser for help on using the repository browser.