source: trunk/dll/comp.c@ 771

Last change on this file since 771 was 771, checked in by Gregg Young, 18 years ago

Increase subject to 1024 reduce DosSleep times
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 73.2 KB
Line 
1
2/***********************************************************************
3
4 $Id: comp.c 771 2007-08-06 03:05:35Z gyoung $
5
6 Compare directories
7
8 Copyright (c) 1993-02 M. Kimes
9 Copyright (c) 2003, 2007 Steven H. Levine
10
11 16 Oct 02 MK Baseline
12 04 Nov 03 SHL Force window refresh after subdir toggle
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 24 May 05 SHL Rework Win_Error usage
15 24 May 05 SHL Rework for CNRITEM.szSubject
16 25 May 05 SHL Rework with ULONGLONG
17 06 Jun 05 SHL Drop unused
18 12 Jul 06 SHL Renames and comments
19 13 Jul 06 SHL Use Runtime_Error
20 26 Jul 06 SHL Drop unreachable CN_... code
21 29 Jul 06 SHL Use xfgets_bstripcr
22 15 Aug 06 SHL Turn off hide not selected on dir change
23 19 Oct 06 SHL Correct . and .. detect
24 03 Nov 06 SHL Count thread usage
25 22 Mar 07 GKY Use QWL_USER
26 29 Jul 07 SHL Use Win_Error to report container errors
27 01 Aug 07 SHL Rework to sync with CNRITEM mods
28 01 Aug 07 SHL Rework to remove vast amount of duplicate code
29 03 Aug 07 GKY Enlarged and made setable everywhere Findbuf (speed file loading)
30
31***********************************************************************/
32
33#define INCL_DOS
34#define INCL_WIN
35#define INCL_GPI
36#define INCL_LONGLONG
37#include <os2.h>
38
39#include <stdio.h>
40#include <stdlib.h>
41#include <string.h>
42#include <ctype.h>
43#include <share.h>
44#include <io.h>
45#include <process.h> // _beginthread
46
47#include "fm3dll.h"
48#include "fm3dlg.h"
49#include "fm3str.h"
50
51#pragma alloc_text(COMPAREDIR,FillCnrsThread,FillDirList,CompNames)
52#pragma alloc_text(COMPAREDIR1,CompareDlgProc)
53#pragma alloc_text(COMPAREDIR2,SelectCnrsThread,ActionCnrThread)
54#pragma alloc_text(COMPAREFILE,CFileDlgProc,CompareFilesThread)
55#pragma alloc_text(SNAPSHOT,SnapShot,StartSnap)
56
57typedef struct
58{
59 CHAR filename[CCHMAXPATH];
60 CHAR dirname[CCHMAXPATH];
61 BOOL recurse;
62}
63SNAPSTUFF;
64
65static PSZ pszSrcFile = __FILE__;
66
67//=== SnapShot() Write directory tree to file and recurse if requested ===
68
69static VOID SnapShot(char *path, FILE * fp, BOOL recurse)
70{
71 FILEFINDBUF4 *fb;
72 char *mask, *enddir;
73 HDIR hdir = HDIR_CREATE;
74 ULONG nm = 1;
75
76 fb = xmalloc(sizeof(FILEFINDBUF4), pszSrcFile, __LINE__);
77 if (fb) {
78 mask = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
79 if (mask) {
80 sprintf(mask,
81 "%s%s*",
82 path, (path[strlen(path) - 1] != '\\') ? "\\" : NullStr);
83 enddir = strrchr(mask, '\\');
84 enddir++;
85 if (!DosFindFirst(mask,
86 &hdir,
87 FILE_NORMAL | FILE_DIRECTORY |
88 FILE_ARCHIVED | FILE_READONLY | FILE_HIDDEN |
89 FILE_SYSTEM,
90 fb, sizeof(FILEFINDBUF4), &nm, FIL_QUERYEASIZE)) {
91 do {
92 strcpy(enddir, fb->achName);
93 if (!(fb->attrFile & FILE_DIRECTORY))
94 fprintf(fp,
95 "\"%s\",%u,%lu,%04u/%02u/%02u,%02u:%02u:%02u,%lu,%lu,N\n",
96 mask,
97 enddir - mask,
98 fb->cbFile,
99 (fb->fdateLastWrite.year + 1980),
100 fb->fdateLastWrite.month,
101 fb->fdateLastWrite.day,
102 fb->ftimeLastWrite.hours,
103 fb->ftimeLastWrite.minutes,
104 fb->ftimeLastWrite.twosecs,
105 fb->attrFile, (fb->cbList > 4) ? (fb->cbList / 2) : 0);
106 // Skip . and ..
107 else if (recurse &&
108 (fb->achName[0] != '.' ||
109 (fb->achName[1] &&
110 (fb->achName[1] != '.' || fb->achName[2])))) {
111 SnapShot(mask, fp, recurse);
112 }
113 nm = 1;
114 } while (!DosFindNext(hdir, fb, sizeof(FILEFINDBUF4), &nm));
115 DosFindClose(hdir);
116 }
117 free(mask);
118 }
119 free(fb);
120 }
121}
122
123//=== StartSnap() Write directory tree to snapshot file ===
124
125static VOID StartSnap(VOID * dummy)
126{
127 SNAPSTUFF *sf = (SNAPSTUFF *) dummy;
128 FILE *fp;
129 CHAR *p;
130
131 if (sf) {
132 if (*sf->dirname && *sf->filename) {
133 priority_normal();
134 p = sf->dirname;
135 while (*p) {
136 if (*p == '/')
137 *p = '\\';
138 p++;
139 }
140 if (*(p - 1) != '\\') {
141 *p = '\\';
142 p++;
143 }
144 fp = xfopen(sf->filename, "w", pszSrcFile, __LINE__);
145 if (fp) {
146 fprintf(fp, "\"%s\"\n", sf->dirname);
147 SnapShot(sf->dirname, fp, sf->recurse);
148 fclose(fp);
149 }
150 }
151 free(sf);
152 }
153}
154
155//=== CompareFilesThread() Compare files and update container select flags ===
156
157static VOID CompareFilesThread(VOID * args)
158{
159 FCOMPARE fc;
160 HAB hab2;
161 HMQ hmq2;
162 FILE *fp1, *fp2;
163 ULONG len1, len2, offset = 0L;
164 LONG numread1, numread2;
165 CHAR s[1024], ss[1024], *p1, *p2;
166
167 if (args) {
168 fc = *(FCOMPARE *) args;
169 hab2 = WinInitialize(0);
170 if (hab2) {
171 hmq2 = WinCreateMsgQueue(hab2, 0);
172 if (hmq2) {
173 WinCancelShutdown(hmq2, TRUE);
174 IncrThreadUsage();
175 if (!IsFile(fc.file1) || IsRoot(fc.file1)) {
176 p1 = strrchr(fc.file2, '\\');
177 if (p1) {
178 if (fc.file1[strlen(fc.file1) - 1] == '\\')
179 p1++;
180 strcat(fc.file1, p1);
181 }
182 }
183 else if (!IsFile(fc.file2) || IsRoot(fc.file2)) {
184 p1 = strrchr(fc.file1, '\\');
185 if (p1) {
186 if (fc.file2[strlen(fc.file2) - 1] == '\\')
187 p1++;
188 strcat(fc.file2, p1);
189 }
190 }
191 sprintf(s, GetPString(IDS_COMPCOMPARETEXT), fc.file1);
192 AddToListboxBottom(fc.hwndList, s);
193 sprintf(s, GetPString(IDS_COMPTOTEXT), fc.file2);
194 AddToListboxBottom(fc.hwndList, s);
195 fp1 = _fsopen(fc.file1, "rb", SH_DENYNO);
196 if (!fp1) {
197 sprintf(s, GetPString(IDS_COMPCANTOPENTEXT), fc.file1);
198 AddToListboxBottom(fc.hwndList, s);
199 WinSetWindowText(fc.hwndHelp, GetPString(IDS_ERRORTEXT));
200 }
201 else {
202 fp2 = _fsopen(fc.file2, "rb", SH_DENYNO);
203 if (!fp2) {
204 sprintf(s, GetPString(IDS_COMPCANTOPENTEXT), fc.file2);
205 AddToListboxBottom(fc.hwndList, s);
206 WinSetWindowText(fc.hwndHelp, GetPString(IDS_ERRORTEXT));
207 }
208 else {
209 len1 = filelength(fileno(fp1));
210 len2 = filelength(fileno(fp2));
211 if (len1 != len2) {
212 strcpy(s, GetPString(IDS_COMPDIFSIZESTEXT));
213 AddToListboxBottom(fc.hwndList, s);
214 sprintf(s, GetPString(IDS_COMPVSBYTESTEXT), len1, len2);
215 AddToListboxBottom(fc.hwndList, s);
216 WinSetWindowText(fc.hwndHelp,
217 GetPString(IDS_COMPDONTMATCHTEXT));
218 }
219 else {
220 WinSetWindowText(fc.hwndHelp,
221 GetPString(IDS_COMPCOMPARINGTEXT));
222 while (WinIsWindow(hab2, fc.hwndList)) {
223 numread1 = fread(s, 1, 1024, fp1);
224 numread2 = fread(ss, 1, 1024, fp2);
225 if (numread1 != numread2 || feof(fp1) != feof(fp2)) {
226 sprintf(s, GetPString(IDS_COMPREADERRORTEXT),
227 offset, offset);
228 AddToListboxBottom(fc.hwndList, s);
229 WinSetWindowText(fc.hwndHelp, GetPString(IDS_ERRORTEXT));
230 break;
231 }
232 else if (!numread1 && feof(fp1) && feof(fp2)) {
233 AddToListboxBottom(fc.hwndList,
234 GetPString(IDS_COMPFILESMATCHTEXT));
235 if (!stricmp(fc.file1, fc.file2))
236 AddToListboxBottom(fc.hwndList,
237 GetPString(IDS_COMPWONDERWHYTEXT));
238 WinSetWindowText(fc.hwndHelp,
239 GetPString(IDS_COMPCOMPLETETEXT));
240 break;
241 }
242 else if (numread1 <= 0 || numread2 <= 0) {
243 if (offset == len1)
244 break;
245 else {
246 sprintf(s, GetPString(IDS_COMPMATCHREADERRORTEXT),
247 offset, offset);
248 WinSetWindowText(fc.hwndHelp,
249 GetPString(IDS_COMPODDERRORTEXT));
250 AddToListboxBottom(fc.hwndList, s);
251 break;
252 }
253 }
254 else if (memcmp(s, ss, numread1)) {
255 p1 = s;
256 p2 = ss;
257 while (p1 < s + numread1) {
258 if (*p1 != *p2) {
259 sprintf(s, GetPString(IDS_COMPMISMATCHERRORTEXT),
260 offset + (p1 - s), offset + (p1 - s));
261 AddToListboxBottom(fc.hwndList, s);
262 WinSetWindowText(fc.hwndHelp,
263 GetPString(IDS_COMPDONTMATCHTEXT));
264 break;
265 }
266 p1++;
267 p2++;
268 }
269 break;
270 }
271 offset += numread1;
272 }
273 }
274 fclose(fp2);
275 }
276 fclose(fp1);
277 }
278 DecrThreadUsage();
279 WinDestroyMsgQueue(hmq2);
280 }
281 WinTerminate(hab2);
282 }
283 }
284}
285
286//=== CFileDlgProc() Select directories to compare dialog procedure ===
287
288MRESULT EXPENTRY CFileDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
289{
290 FCOMPARE *fc;
291
292 switch (msg) {
293 case WM_INITDLG:
294 if (!mp2)
295 WinDismissDlg(hwnd, 0);
296 else {
297 WinSetWindowPtr(hwnd, QWL_USER, mp2);
298 fc = (FCOMPARE *) mp2;
299 fc->hwndReport = hwnd;
300 fc->hwndList = WinWindowFromID(hwnd, FCMP_LISTBOX);
301 fc->hwndHelp = WinWindowFromID(hwnd, FCMP_HELP);
302 if (!*fc->file1 || !fc->file2) {
303 WinDismissDlg(hwnd, 0);
304 break;
305 }
306 MakeFullName(fc->file1);
307 MakeFullName(fc->file2);
308 if (!stricmp(fc->file1, fc->file2)) {
309 saymsg(MB_CANCEL, hwnd,
310 GetPString(IDS_COMPSILLYALERTTEXT),
311 GetPString(IDS_COMPTOITSELFTEXT));
312 WinDismissDlg(hwnd, 0);
313 break;
314 }
315 if (_beginthread(CompareFilesThread, NULL, 65536, (PVOID) fc) == -1) {
316 Runtime_Error(pszSrcFile, __LINE__,
317 GetPString(IDS_COULDNTSTARTTHREADTEXT));
318 WinDismissDlg(hwnd, 0);
319 }
320 }
321 break;
322
323 case WM_ADJUSTWINDOWPOS:
324 PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
325 break;
326
327 case UM_SETDIR:
328 PaintRecessedWindow(WinWindowFromID(hwnd, FCMP_HELP),
329 (HPS) 0, FALSE, TRUE);
330 return 0;
331
332 case WM_COMMAND:
333 switch (SHORT1FROMMP(mp1)) {
334 case DID_OK:
335 WinDismissDlg(hwnd, 0);
336 break;
337 case DID_CANCEL:
338 WinDismissDlg(hwnd, 1);
339 break;
340 }
341 return 0;
342
343 case WM_DESTROY:
344 DosSleep(50);//05 Aug 07 GKY 100
345 break;
346 }
347 return WinDefDlgProc(hwnd, msg, mp1, mp2);
348}
349
350//=== ActionCnrThread() Do requested action on container contents ===
351
352static VOID ActionCnrThread(VOID *args)
353{
354 COMPARE *cmp = (COMPARE *)args;
355 HAB hab;
356 HMQ hmq;
357 HWND hwndCnrS, hwndCnrD;
358 PCNRITEM pci, pciD, pciNextS, pciNextD;
359 CHAR szNewName[CCHMAXPATH], szDirName[CCHMAXPATH], *p;
360 APIRET rc;
361
362 if (!cmp) {
363 Runtime_Error(pszSrcFile, __LINE__, "no data");
364 return;
365 }
366
367 DosError(FERR_DISABLEHARDERR);
368
369 hab = WinInitialize(0);
370 if (hab) {
371 hmq = WinCreateMsgQueue(hab, 0);
372 if (hmq) {
373 WinCancelShutdown(hmq, TRUE);
374 IncrThreadUsage();
375 priority_normal();
376 switch (cmp->action) {
377 case COMP_DELETELEFT:
378 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
379 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
380 cmp->action = IDM_DELETE;
381 break;
382 case COMP_DELETERIGHT:
383 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
384 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
385 cmp->action = IDM_DELETE;
386 break;
387 case COMP_MOVELEFT:
388 cmp->action = IDM_MOVE;
389 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
390 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
391 break;
392 case COMP_MOVERIGHT:
393 cmp->action = IDM_MOVE;
394 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
395 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
396 break;
397 case COMP_COPYLEFT:
398 cmp->action = IDM_COPY;
399 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
400 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
401 break;
402 case COMP_COPYRIGHT:
403 cmp->action = IDM_COPY;
404 hwndCnrS = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
405 hwndCnrD = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
406 break;
407 default:
408 Runtime_Error(pszSrcFile, __LINE__, "bad case %u", cmp->action);
409 goto Abort;
410 }
411
412 pci = WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPVOID,
413 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
414 pciD = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPVOID,
415 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
416
417 while (pci && (INT)pci != -1 && pciD && (INT)pciD != -1) {
418
419 pciNextS = WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPFROMP(pci),
420 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
421 pciNextD = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciD),
422 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
423
424 if (*pci->pszFileName && pci->rc.flRecordAttr & CRA_SELECTED) {
425
426 // Source name not blank
427 switch (cmp->action) {
428 case IDM_DELETE:
429 if (!unlinkf("%s", pci->pszFileName)) {
430 WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
431 MPFROM2SHORT(FALSE, CRA_SELECTED));
432
433 if (!*pciD->pszFileName) {
434 // Other side is blank - remove from both sides
435 RemoveCnrItems(hwndCnrS, pci, 1, CMA_FREE | CMA_INVALIDATE);
436 if (pciD->rc.flRecordAttr & CRA_SELECTED)
437 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
438 MPFROM2SHORT(FALSE, CRA_SELECTED));
439 RemoveCnrItems(hwndCnrD, pciD, 1, CMA_FREE | CMA_INVALIDATE);
440 }
441 else {
442 // Other side is not blank - update just this side
443 FreeCnrItemData(pci);
444 pci->pszDisplayName = pci->pszFileName;
445 pci->rc.pszIcon = pci->pszFileName;
446 pci->flags = 0;
447 WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
448 MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
449 }
450 if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_LEFTDIR))
451 cmp->cmp->totalleft--;
452 else
453 cmp->cmp->totalright--;
454 DosSleep(1);
455 }
456 break;
457
458 case IDM_MOVE:
459 if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
460 // 02 Aug 07 SHL fixme to replace this kind of stuff with _makepath or equivalent
461 BldFullPathName(szNewName, cmp->leftdir, pci->pszDisplayName);
462 //sprintf(szNewName, "%s%s%s",
463 // cmp->leftdir,
464 // cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ?
465 // NullStr : "\\",
466 // pci->pszDisplayName);
467 else
468 BldFullPathName(szNewName, cmp->rightdir, pci->pszDisplayName);
469 //sprintf(szNewName, "%s%s%s",
470 // cmp->rightdir,
471 // cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ?
472 // NullStr : "\\",
473 // pci->pszDisplayName);
474 // Make directory if required
475 strcpy(szDirName, szNewName);
476 p = strrchr(szDirName, '\\');
477 if (p) {
478 if (p > szDirName + 2)
479 p++;
480 *p = 0;
481 if (IsFile(szDirName) == -1)
482 MassMkdir(hwndMain, szDirName);
483 }
484 rc = docopyf(MOVE, pci->pszFileName, "%s", szNewName);
485 if (!rc && stricmp(pci->pszFileName, szNewName)) {
486 WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
487 MPFROM2SHORT(FALSE, CRA_SELECTED));
488 if (pciD->rc.flRecordAttr & CRA_SELECTED)
489 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
490 MPFROM2SHORT(FALSE, CRA_SELECTED));
491 FreeCnrItemData(pciD);
492 pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
493 if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
494 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
495 if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
496 pciD->pszDisplayName++;
497 }
498 else {
499 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
500 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
501 pciD->pszDisplayName++;
502 }
503 // 02 Aug 07 SHL fixme to know if LongName transfer is correct?
504 pciD->pszLongName = pci->pszLongName;
505 if (pciD->pszSubject != NullStr) {
506 xfree(pciD->pszSubject);
507 pciD->pszSubject = NullStr;
508 }
509 pciD->attrFile = pci->attrFile;
510 pciD->pszDispAttr = pci->pszDispAttr;
511 pciD->flags = 0; // Just on one side
512 pciD->date = pci->date;
513 pciD->time = pci->time;
514 pciD->ladate = pci->ladate;
515 pciD->latime = pci->latime;
516 pciD->crdate = pci->crdate;
517 pciD->crtime = pci->crtime;
518 pciD->cbFile = pci->cbFile;
519 pciD->easize = pci->easize;
520
521 if (pci->pszFileName != NullStr) {
522 xfree(pci->pszFileName);
523 pci->pszFileName = NullStr;
524 pci->pszDisplayName = pci->pszFileName;
525 pci->rc.pszIcon = pci->pszFileName;
526 }
527 if (pci->pszSubject != NullStr) {
528 xfree(pci->pszSubject);
529 pci->pszSubject = NullStr;
530 }
531 pci->flags = 0;
532
533 WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
534 MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
535 WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
536 MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
537 }
538 else if (rc) {
539 rc = Dos_Error(MB_ENTERCANCEL,
540 rc,
541 HWND_DESKTOP,
542 pszSrcFile,
543 __LINE__,
544 GetPString(IDS_COMPMOVEFAILEDTEXT),
545 pci->pszFileName, szNewName);
546 if (rc == MBID_CANCEL) // Cause loop to break
547 pciNextS = NULL;
548 }
549 break;
550
551 case IDM_COPY:
552 if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
553 BldFullPathName(szNewName, cmp->leftdir, pci->pszDisplayName);
554 //sprintf(szNewName, "%s%s%s",
555 // cmp->leftdir,
556 // cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ?
557 // NullStr : "\\",
558 // pci->pszDisplayName);
559 else
560 BldFullPathName(szNewName, cmp->rightdir, pci->pszDisplayName);
561 //sprintf(szNewName, "%s%s%s",
562 // cmp->rightdir,
563 // cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ?
564 // NullStr : "\\",
565 // pci->pszDisplayName);
566 // Make directory if required
567 strcpy(szDirName, szNewName);
568 p = strrchr(szDirName, '\\');
569 if (p) {
570 if (p > szDirName + 2)
571 p++;
572 *p = 0;
573 if (IsFile(szDirName) == -1)
574 MassMkdir(hwndMain, szDirName);
575 }
576 rc = docopyf(COPY, pci->pszFileName, "%s", szNewName);
577 if (rc) {
578 rc = Dos_Error(MB_ENTERCANCEL,
579 rc,
580 HWND_DESKTOP,
581 pszSrcFile,
582 __LINE__,
583 GetPString(IDS_COMPCOPYFAILEDTEXT),
584 pci->pszFileName, szNewName);
585 if (rc == MBID_CANCEL)
586 pciNextS = NULL; // Cause loop to break
587 }
588 else {
589 WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
590 MPFROM2SHORT(FALSE, CRA_SELECTED));
591 if (pciD->rc.flRecordAttr & CRA_SELECTED)
592 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
593 MPFROM2SHORT(FALSE, CRA_SELECTED));
594 FreeCnrItemData(pciD);
595 pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
596 if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
597 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
598 if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
599 pciD->pszDisplayName++;
600 }
601 else {
602 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
603 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
604 pciD->pszDisplayName++;
605 }
606 pciD->attrFile = pci->attrFile;
607 pciD->pszDispAttr = pci->pszDispAttr;
608 pciD->flags = CNRITEM_EXISTS; // Now on both sides
609 pciD->date = pci->date;
610 pciD->time = pci->time;
611 pciD->ladate = pci->ladate;
612 pciD->latime = pci->latime;
613 pciD->crdate = pci->crdate;
614 pciD->crtime = pci->crtime;
615 pciD->cbFile = pci->cbFile;
616 pciD->easize = pci->easize;
617
618 // Forget status until we regenerate it
619 if (pci->pszSubject != NullStr) {
620 xfree(pci->pszSubject);
621 pci->pszSubject = NullStr;
622 }
623 pci->flags = CNRITEM_EXISTS;
624
625 WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
626 MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
627 WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
628 MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
629 }
630 break;
631
632 default:
633 break;
634 } // switch
635
636 } // if have name
637
638 pci = pciNextS;
639 pciD = pciNextD;
640
641 } // while
642 Abort:
643 WinDestroyMsgQueue(hmq);
644 }
645 DecrThreadUsage();
646 WinTerminate(hab);
647 }
648 PostMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPFROMLONG(1L), MPVOID);
649 PostMsg(cmp->hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DESELECTALL, 0), MPVOID);
650 free(cmp);
651}
652
653//=== SelectCnrsThread() Update container selection flags thread ===
654
655static VOID SelectCnrsThread(VOID * args)
656{
657 COMPARE *cmp = (COMPARE *) args;
658 HAB hab;
659 HMQ hmq;
660
661 if (!cmp)
662 return;
663
664 DosError(FERR_DISABLEHARDERR);
665
666 hab = WinInitialize(0);
667 if (hab) {
668 hmq = WinCreateMsgQueue(hab, 0);
669 if (hmq) {
670 WinCancelShutdown(hmq, TRUE);
671 IncrThreadUsage();
672 priority_normal();
673 switch (cmp->action) {
674 case IDM_INVERT:
675 InvertAll(WinWindowFromID(cmp->hwnd, COMP_LEFTDIR));
676 InvertAll(WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR));
677 break;
678
679 case IDM_DESELECTALL:
680 Deselect(WinWindowFromID(cmp->hwnd, COMP_LEFTDIR));
681 Deselect(WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR));
682 break;
683
684 default:
685 SpecialSelect(WinWindowFromID(cmp->hwnd, COMP_LEFTDIR),
686 WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR),
687 cmp->action, cmp->reset);
688 break;
689 }
690 if (!PostMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPFROMLONG(1L), MPVOID))
691 WinSendMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPFROMLONG(1L), MPVOID);
692 WinDestroyMsgQueue(hmq);
693 }
694 DecrThreadUsage();
695 WinTerminate(hab);
696 }
697 free(cmp);
698}
699
700/**
701 * Build FILELIST given pathname
702 */
703
704static VOID FillDirList(CHAR *str, INT skiplen, BOOL recurse,
705 FILELIST ***list, INT *numfiles, INT *numalloc)
706{
707
708 BYTE *fb;
709 CHAR *enddir;
710 ULONG x;
711 CHAR *maskstr;
712 FILEFINDBUF4 *ffb4, *pffb;
713 HDIR hDir;
714 ULONG nm, fl = 0, ulM = FilesToGet;
715 APIRET rc;
716
717 if (!str || !*str) {
718 Runtime_Error(pszSrcFile, __LINE__, "no data");
719 return;
720 }
721
722 //if (!recurse)
723 // ulM = FilesToGet;
724 maskstr = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
725 if (!maskstr)
726 return;
727 ffb4 = xmalloc(sizeof(FILEFINDBUF4) * ulM, pszSrcFile, __LINE__);
728 if (!ffb4) {
729 free(maskstr);
730 return;
731 }
732 x = strlen(str);
733 memcpy(maskstr, str, x + 1);
734 enddir = maskstr + x;
735 if (*(enddir - 1) != '\\') {
736 *enddir = '\\';
737 enddir++;
738 *enddir = 0;
739 }
740 *enddir = '*';
741 *(enddir + 1) = 0;
742 hDir = HDIR_CREATE;
743 nm = ulM;
744 if (recurse)
745 fl = FILE_DIRECTORY;
746 DosError(FERR_DISABLEHARDERR);
747 rc = DosFindFirst(maskstr, &hDir,
748 (FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
749 FILE_SYSTEM | FILE_HIDDEN) | fl,
750 ffb4, sizeof(FILEFINDBUF4) * nm, &nm, FIL_QUERYEASIZE);
751 if (!rc) {
752 while (!rc) {
753 fb = (BYTE *) ffb4;
754 x = 0;
755 while (x < nm) {
756 pffb = (FILEFINDBUF4 *) fb;
757 if (pffb->attrFile & FILE_DIRECTORY) {
758 // Skip . and ..
759 if (recurse &&
760 (pffb->achName[0] != '.' ||
761 (pffb->achName[1] &&
762 (pffb->achName[1] != '.' || pffb->achName[2])))) {
763 if (fForceUpper)
764 strupr(pffb->achName);
765 else if (fForceLower)
766 strlwr(pffb->achName);
767 memcpy(enddir, pffb->achName, pffb->cchName + 1);
768 FillDirList(maskstr, skiplen, recurse, list, numfiles, numalloc);
769 }
770 }
771 else {
772 if (fForceUpper)
773 strupr(pffb->achName);
774 else if (fForceLower)
775 strlwr(pffb->achName);
776 memcpy(enddir, pffb->achName, pffb->cchName + 1);
777 if (AddToFileList
778 (maskstr + skiplen, pffb, list, numfiles, numalloc))
779 goto Abort;
780 }
781 fb += pffb->oNextEntryOffset;
782 x++;
783 }
784 nm = ulM;
785 DosError(FERR_DISABLEHARDERR);
786 rc = DosFindNext(hDir, ffb4, sizeof(FILEFINDBUF4) * nm, &nm);
787 }
788 Abort:
789 DosFindClose(hDir);
790 DosSleep(1);
791 }
792 free(maskstr);
793 free(ffb4);
794}
795
796//=== CompNames() Compare names for qsort ===
797
798static int CompNames(const void *n1, const void *n2)
799{
800 FILELIST *fl1 = *(FILELIST **) n1;
801 FILELIST *fl2 = *(FILELIST **) n2;
802
803 return stricmp(fl1->fname, fl2->fname);
804}
805
806//=== FillCnrsThread() Fill left and right containers ===
807
808static VOID FillCnrsThread(VOID *args)
809{
810 COMPARE *cmp = (COMPARE *) args;
811 HAB hab;
812 HMQ hmq;
813 BOOL notified = FALSE;
814
815 HWND hwndLeft, hwndRight;
816 CHAR szBuf[CCHMAXPATH];
817 CNRINFO cnri;
818
819 if (!cmp) {
820 Runtime_Error(pszSrcFile, __LINE__, "no data");
821 _endthread();
822 }
823
824 DosError(FERR_DISABLEHARDERR);
825
826 hab = WinInitialize(0);
827 if (!hab)
828 Win_Error(NULLHANDLE, NULLHANDLE, pszSrcFile, __LINE__, "WinInitialize");
829 else {
830 hmq = WinCreateMsgQueue(hab, 0);
831 if (!hmq)
832 Win_Error(NULLHANDLE, NULLHANDLE, pszSrcFile, __LINE__,
833 "WinCreateMsgQueue");
834 else {
835 INT x;
836 INT l;
837 INT r;
838 ULONG cntr;
839 FILELIST **filesl = NULL;
840 FILELIST **filesr = NULL;
841 INT numfilesl = 0;
842 INT numfilesr = 0;
843 INT numallocl = 0;
844 INT numallocr = 0;
845 UINT lenl; // Directory prefix length
846 UINT lenr;
847 UINT recsNeeded;
848 PCNRITEM pcilFirst;
849 PCNRITEM pcirFirst;
850 PCNRITEM pcil;
851 PCNRITEM pcir;
852 RECORDINSERT ri;
853 CHAR *pch;
854
855 WinCancelShutdown(hmq, TRUE);
856 IncrThreadUsage();
857 hwndLeft = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
858 hwndRight = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
859 lenl = strlen(cmp->leftdir);
860 if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
861 lenl++;
862 lenr = strlen(cmp->rightdir);
863 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
864 lenr++;
865 priority_normal();
866 // Clear containers
867 RemoveCnrItems(hwndRight, NULL, 0, CMA_FREE | CMA_INVALIDATE);
868 RemoveCnrItems(hwndLeft, NULL, 0, CMA_FREE | CMA_INVALIDATE);
869 cmp->cmp->totalleft = cmp->cmp->totalright = 0;
870
871 // Build list of all files in left directory
872 if (fForceLower)
873 strlwr(cmp->leftdir);
874 else if (fForceUpper)
875 strupr(cmp->leftdir);
876 FillDirList(cmp->leftdir, lenl, cmp->includesubdirs,
877 &filesl, &numfilesl, &numallocl);
878
879 if (filesl)
880 qsort(filesl, numfilesl, sizeof(CHAR *), CompNames);
881
882 // Build list of all files in right directory
883 if (!*cmp->rightlist) {
884 if (fForceLower)
885 strlwr(cmp->rightdir);
886 else if (fForceUpper)
887 strupr(cmp->rightdir);
888 FillDirList(cmp->rightdir, lenr, cmp->includesubdirs,
889 &filesr, &numfilesr, &numallocr);
890 }
891 else {
892 // Use snapshot file
893 FILE *fp;
894 FILEFINDBUF4 fb4;
895 CHAR str[CCHMAXPATH * 2], *p;
896
897 memset(&fb4, 0, sizeof(fb4));
898 fp = fopen(cmp->rightlist, "r");
899 if (!fp)
900 Runtime_Error(pszSrcFile, __LINE__, "can not open %s (%d)",
901 cmp->rightlist, errno);
902 else {
903 while (!feof(fp)) {
904 // First get name of directory
905 if (!xfgets_bstripcr(str, sizeof(str), fp, pszSrcFile, __LINE__))
906 break; // EOF
907 p = str;
908 if (*p == '\"') {
909 // Quoted
910 p++;
911 if (*p && *p != '\"') {
912 p = strchr(p, '\"');
913 if (p) {
914 *p = 0;
915 if (*(str + 1)) {
916 strcpy(cmp->rightdir, str + 1);
917 if (fForceUpper)
918 strupr(cmp->rightdir);
919 else if (fForceLower)
920 strlwr(cmp->rightdir);
921 p = cmp->rightdir + (strlen(cmp->rightdir) - 1);
922 if (p - cmp->rightdir > 3 && *p == '\\')
923 *p = 0; // Chop trailing slash
924 break;
925 }
926 }
927 }
928 }
929 } // while !EOF
930
931 memset(&cnri, 0, sizeof(cnri));
932 cnri.cb = sizeof(cnri);
933 cnri.pszCnrTitle = cmp->rightdir;
934 if (!WinSendMsg(hwndRight, CM_SETCNRINFO,
935 MPFROMP(&cnri), MPFROMLONG(CMA_CNRTITLE))) {
936 Win_Error(hwndRight, cmp->hwnd, pszSrcFile, __LINE__, "CM_SETCNRINFO");
937 }
938
939 if (*cmp->rightdir) {
940 lenr = strlen(cmp->rightdir);
941 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
942 lenr++;
943 while (!feof(fp)) {
944 if (!xfgets_bstripcr
945 (str, sizeof(str), fp, pszSrcFile, __LINE__))
946 break;
947 p = str;
948 if (*p == '\"') {
949 p++;
950 if (*p && *p != '\"') {
951 p = strchr(p, '\"');
952 if (p) {
953 *p = 0;
954 p++;
955 if (*p == ',') {
956 p++;
957 if (!cmp->includesubdirs && atol(p) > lenr)
958 continue;
959 p = strchr(p, ',');
960 if (p) {
961 p++;
962 fb4.cbFile = atol(p);
963 p = strchr(p, ',');
964 if (p) {
965 p++;
966 fb4.fdateLastWrite.year = atol(p) - 1980;
967 p = strchr(p, '/');
968 if (p) {
969 p++;
970 fb4.fdateLastWrite.month = atol(p);
971 p = strchr(p, '/');
972 if (p) {
973 p++;
974 fb4.fdateLastWrite.day = atol(p);
975 p = strchr(p, ',');
976 if (p) {
977 p++;
978 fb4.ftimeLastWrite.hours = atol(p);
979 p = strchr(p, ':');
980 if (p) {
981 p++;
982 fb4.ftimeLastWrite.minutes = atol(p);
983 p = strchr(p, ':');
984 if (p) {
985 p++;
986 fb4.ftimeLastWrite.twosecs = atol(p);
987 p = strchr(p, ',');
988 if (p) {
989 p++;
990 fb4.attrFile = atol(p);
991 p = strchr(p, ',');
992 if (p) {
993 p++;
994 fb4.cbList = atol(p) * 2;
995 if (fForceUpper)
996 strupr(str + 1);
997 else if (fForceLower)
998 strlwr(str + 1);
999 if (AddToFileList((str + 1) + lenr,
1000 &fb4,
1001 &filesr,
1002 &numfilesr,
1003 &numallocr))
1004 break;
1005 }
1006 }
1007 }
1008 }
1009 }
1010 }
1011 }
1012 }
1013 }
1014 }
1015 }
1016 }
1017 }
1018 } // while
1019 } // if have rightdir
1020 fclose(fp);
1021 }
1022 } // if snapshot file
1023
1024 if (filesr)
1025 qsort(filesr, numfilesr, sizeof(CHAR *), CompNames);
1026
1027 // We now have two lists of files, both sorted.
1028 // Count total number of container entries required on each side
1029 l = r = 0;
1030 recsNeeded = 0;
1031 while ((filesl && filesl[l]) || (filesr && filesr[r])) {
1032
1033 if (filesl && filesl[l]) {
1034 if (filesr && filesr[r])
1035 x = stricmp(filesl[l]->fname, filesr[r]->fname);
1036 else
1037 x = -1; // Left side list longer
1038 }
1039 else
1040 x = +1; // Right side list longer
1041
1042 if (x <= 0)
1043 l++; // On left side
1044 if (x >= 0)
1045 r++; // On right side
1046
1047 recsNeeded++; // Keep count of how many entries req'd
1048
1049 } // while
1050
1051 WinSendMsg(cmp->hwnd, UM_CONTAINERHWND, MPVOID, MPVOID);
1052
1053 // Now insert records into the containers
1054 cntr = 0;
1055 l = r = 0;
1056 if (recsNeeded) {
1057 pcilFirst = WinSendMsg(hwndLeft,
1058 CM_ALLOCRECORD,
1059 MPFROMLONG(EXTRA_RECORD_BYTES),
1060 MPFROMLONG(recsNeeded));
1061 if (!pcilFirst) {
1062 Win_Error(hwndLeft, cmp->hwnd, pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed",
1063 recsNeeded);
1064 recsNeeded = 0;
1065 }
1066 }
1067 if (recsNeeded) {
1068 pcirFirst = WinSendMsg(hwndRight, CM_ALLOCRECORD,
1069 MPFROMLONG(EXTRA_RECORD_BYTES),
1070 MPFROMLONG(recsNeeded));
1071 if (!pcirFirst) {
1072 Win_Error(hwndRight, cmp->hwnd, pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed",
1073 recsNeeded);
1074 recsNeeded = 0;
1075 FreeCnrItemList(hwndLeft, pcilFirst);
1076 }
1077 }
1078
1079 if (recsNeeded) {
1080
1081 pcil = pcilFirst;
1082 pcir = pcirFirst;
1083 while ((filesl && filesl[l]) || (filesr && filesr[r])) {
1084 pcir->hwndCnr = hwndRight;
1085 pcir->rc.hptrIcon = (HPOINTER) 0;
1086 pcil->hwndCnr = hwndLeft;
1087 pcil->rc.hptrIcon = (HPOINTER) 0;
1088
1089 if (filesl && filesl[l]) {
1090 if (filesr && filesr[r])
1091 x = stricmp(filesl[l]->fname, filesr[r]->fname);
1092 else
1093 x = -1; // Left side list longer
1094 }
1095 else
1096 x = +1; // Right side list longer
1097
1098 if (x <= 0) {
1099 // File appears on left side
1100 BldFullPathName(szBuf, cmp->leftdir, filesl[l]->fname);
1101 //sprintf(szBuf, "%s%s%s", cmp->leftdir,
1102 // (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
1103 // NullStr : "\\", filesl[l]->fname);
1104 pcil->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
1105 pcil->pszDisplayName = pcil->pszFileName + lenl;
1106 pcil->attrFile = filesl[l]->attrFile;
1107 pcil->pszDispAttr = FileAttrToString(pcil->attrFile);
1108 pcil->cbFile = filesl[l]->cbFile;
1109 pcil->easize = filesl[l]->easize;
1110 pcil->date.day = filesl[l]->date.day;
1111 pcil->date.month = filesl[l]->date.month;
1112 pcil->date.year = filesl[l]->date.year + 1980;
1113 pcil->time.seconds = filesl[l]->time.twosecs * 2;
1114 pcil->time.minutes = filesl[l]->time.minutes;
1115 pcil->time.hours = filesl[l]->time.hours;
1116 pcil->ladate.day = filesl[l]->ladate.day;
1117 pcil->ladate.month = filesl[l]->ladate.month;
1118 pcil->ladate.year = filesl[l]->ladate.year + 1980;
1119 pcil->latime.seconds = filesl[l]->latime.twosecs * 2;
1120 pcil->latime.minutes = filesl[l]->latime.minutes;
1121 pcil->latime.hours = filesl[l]->latime.hours;
1122 pcil->crdate.day = filesl[l]->crdate.day;
1123 pcil->crdate.month = filesl[l]->crdate.month;
1124 pcil->crdate.year = filesl[l]->crdate.year + 1980;
1125 pcil->crtime.seconds = filesl[l]->crtime.twosecs * 2;
1126 pcil->crtime.minutes = filesl[l]->crtime.minutes;
1127 pcil->crtime.hours = filesl[l]->crtime.hours;
1128 if (*cmp->dcd.mask.szMask) {
1129 if (!Filter((PMINIRECORDCORE) pcil, (PVOID)&cmp->dcd.mask)) {
1130 pcil->rc.flRecordAttr |= CRA_FILTERED;
1131 pcir->rc.flRecordAttr |= CRA_FILTERED;
1132 }
1133 }
1134 } // if on left
1135
1136 if (x >= 0) {
1137 // File appears on right side
1138 BldFullPathName(szBuf, cmp->rightdir, filesl[r]->fname);
1139 //sprintf(szBuf, "%s%s%s", cmp->rightdir,
1140 // (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
1141 // NullStr : "\\", filesr[r]->fname);
1142 pcir->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__); // 31 Jul 07 SHL
1143 pcir->pszDisplayName = pcir->pszFileName + lenr;
1144 pcir->attrFile = filesr[r]->attrFile;
1145 // pcir->rc.hptrIcon = hptrFile;
1146 pcir->pszDispAttr = FileAttrToString(pcir->attrFile);
1147 pcir->cbFile = filesr[r]->cbFile;
1148 pcir->easize = filesr[r]->easize;
1149 pcir->date.day = filesr[r]->date.day;
1150 pcir->date.month = filesr[r]->date.month;
1151 pcir->date.year = filesr[r]->date.year + 1980;
1152 pcir->time.seconds = filesr[r]->time.twosecs * 2;
1153 pcir->time.minutes = filesr[r]->time.minutes;
1154 pcir->time.hours = filesr[r]->time.hours;
1155 pcir->ladate.day = filesr[r]->ladate.day;
1156 pcir->ladate.month = filesr[r]->ladate.month;
1157 pcir->ladate.year = filesr[r]->ladate.year + 1980;
1158 pcir->latime.seconds = filesr[r]->latime.twosecs * 2;
1159 pcir->latime.minutes = filesr[r]->latime.minutes;
1160 pcir->latime.hours = filesr[r]->latime.hours;
1161 pcir->crdate.day = filesr[r]->crdate.day;
1162 pcir->crdate.month = filesr[r]->crdate.month;
1163 pcir->crdate.year = filesr[r]->crdate.year + 1980;
1164 pcir->crtime.seconds = filesr[r]->crtime.twosecs * 2;
1165 pcir->crtime.minutes = filesr[r]->crtime.minutes;
1166 pcir->crtime.hours = filesr[r]->crtime.hours;
1167 if (~pcil->rc.flRecordAttr & CRA_FILTERED &&
1168 *cmp->dcd.mask.szMask) {
1169 if (!Filter((PMINIRECORDCORE)pcir, (PVOID)&cmp->dcd.mask)) {
1170 pcil->rc.flRecordAttr |= CRA_FILTERED;
1171 pcir->rc.flRecordAttr |= CRA_FILTERED;
1172 }
1173 }
1174 } // if on right
1175
1176 if (x == 0) {
1177 // File appears on both sides
1178 pcil->flags |= CNRITEM_EXISTS;
1179 pcir->flags |= CNRITEM_EXISTS;
1180 pch = szBuf;
1181 // Subject field holds status messages
1182 *pch = 0;
1183 if (pcil->cbFile + pcil->easize > pcir->cbFile + pcir->easize) {
1184 pcil->flags |= CNRITEM_LARGER;
1185 pcir->flags |= CNRITEM_SMALLER;
1186 strcpy(pch, GetPString(IDS_LARGERTEXT));
1187 pch += 6;
1188 }
1189 else if (pcil->cbFile + pcil->easize <
1190 pcir->cbFile + pcir->easize) {
1191 pcil->flags |= CNRITEM_SMALLER;
1192 pcir->flags |= CNRITEM_LARGER;
1193 strcpy(pch, GetPString(IDS_SMALLERTEXT));
1194 pch += 7;
1195 }
1196 if ((pcil->date.year > pcir->date.year) ? TRUE :
1197 (pcil->date.year < pcir->date.year) ? FALSE :
1198 (pcil->date.month > pcir->date.month) ? TRUE :
1199 (pcil->date.month < pcir->date.month) ? FALSE :
1200 (pcil->date.day > pcir->date.day) ? TRUE :
1201 (pcil->date.day < pcir->date.day) ? FALSE :
1202 (pcil->time.hours > pcir->time.hours) ? TRUE :
1203 (pcil->time.hours < pcir->time.hours) ? FALSE :
1204 (pcil->time.minutes > pcir->time.minutes) ? TRUE :
1205 (pcil->time.minutes < pcir->time.minutes) ? FALSE :
1206 (pcil->time.seconds > pcir->time.seconds) ? TRUE :
1207 (pcil->time.seconds < pcir->time.seconds) ? FALSE : FALSE) {
1208 pcil->flags |= CNRITEM_NEWER;
1209 pcir->flags |= CNRITEM_OLDER;
1210 if (pch != szBuf) {
1211 strcpy(pch, ", ");
1212 pch += 2;
1213 }
1214 strcpy(pch, GetPString(IDS_NEWERTEXT));
1215 pch += 5;
1216 }
1217 else if ((pcil->date.year < pcir->date.year) ? TRUE :
1218 (pcil->date.year > pcir->date.year) ? FALSE :
1219 (pcil->date.month < pcir->date.month) ? TRUE :
1220 (pcil->date.month > pcir->date.month) ? FALSE :
1221 (pcil->date.day < pcir->date.day) ? TRUE :
1222 (pcil->date.day > pcir->date.day) ? FALSE :
1223 (pcil->time.hours < pcir->time.hours) ? TRUE :
1224 (pcil->time.hours > pcir->time.hours) ? FALSE :
1225 (pcil->time.minutes < pcir->time.minutes) ? TRUE :
1226 (pcil->time.minutes > pcir->time.minutes) ? FALSE :
1227 (pcil->time.seconds < pcir->time.seconds) ? TRUE :
1228 (pcil->time.seconds > pcir->time.seconds) ? FALSE :
1229 FALSE) {
1230 pcil->flags |= CNRITEM_OLDER;
1231 pcir->flags |= CNRITEM_NEWER;
1232 if (pch != szBuf) {
1233 strcpy(pch, ", ");
1234 pch += 2;
1235 }
1236 strcpy(pch, GetPString(IDS_OLDERTEXT));
1237 pch += 5;
1238 }
1239 pcil->pszSubject = *szBuf ?
1240 xstrdup(szBuf, pszSrcFile, __LINE__) :
1241 NullStr;
1242
1243 } // if on both sides
1244
1245 if (x <= 0) {
1246 free(filesl[l]);
1247 l++;
1248 }
1249
1250 if (x >= 0) {
1251 free(filesr[r]);
1252 r++;
1253 }
1254
1255 // Ensure empty buffers point somewhere
1256 if (!pcil->pszFileName) {
1257 pcil->pszFileName = NullStr;
1258 pcil->pszDisplayName = pcil->pszFileName;
1259 }
1260
1261 if (!pcir->pszFileName) {
1262 pcir->pszFileName = NullStr;
1263 pcir->pszDisplayName = pcir->pszFileName;
1264 }
1265
1266 pcil->rc.pszIcon = pcil->pszDisplayName;
1267 pcir->rc.pszIcon = pcir->pszDisplayName;
1268
1269 pcil->pszLongName = NullStr;
1270 pcir->pszLongName = NullStr;
1271
1272 if (!pcil->pszSubject)
1273 pcil->pszSubject = NullStr;
1274 if (!pcir->pszSubject)
1275 pcil->pszSubject = NullStr;
1276
1277 if (!pcil->pszDispAttr)
1278 pcil->pszDispAttr = NullStr;
1279 if (!pcir->pszDispAttr)
1280 pcil->pszDispAttr = NullStr;
1281
1282 // fixme to be time based - every 2 sec should be OK
1283 if (!(cntr % 500))
1284 DosSleep(1);
1285 else if (!(cntr % 50))
1286 DosSleep(1);
1287
1288 cntr++;
1289
1290 pcil = (PCNRITEM) pcil->rc.preccNextRecord;
1291 pcir = (PCNRITEM) pcir->rc.preccNextRecord;
1292
1293 } // while filling left or right
1294
1295 if (filesl)
1296 free(filesl); // Free header - have already freed elements
1297 filesl = NULL;
1298 if (filesr)
1299 free(filesr);
1300 filesr = NULL;
1301 // Insert 'em
1302 WinSendMsg(cmp->hwnd, UM_CONTAINERDIR, MPVOID, MPVOID);
1303
1304 memset(&ri, 0, sizeof(RECORDINSERT));
1305 ri.cb = sizeof(RECORDINSERT);
1306 ri.pRecordOrder = (PRECORDCORE) CMA_END;
1307 ri.pRecordParent = (PRECORDCORE) NULL;
1308 ri.zOrder = (ULONG) CMA_TOP;
1309 ri.cRecordsInsert = recsNeeded;
1310 ri.fInvalidateRecord = FALSE;
1311 if (!WinSendMsg(hwndLeft, CM_INSERTRECORD,
1312 MPFROMP(pcilFirst), MPFROMP(&ri))) {
1313 Win_Error(hwndLeft, cmp->hwnd, pszSrcFile, __LINE__, "CM_INSERTRECORD");
1314 FreeCnrItemList(hwndLeft, pcilFirst);
1315 numfilesl = 0;
1316 }
1317
1318 memset(&ri, 0, sizeof(RECORDINSERT));
1319 ri.cb = sizeof(RECORDINSERT);
1320 ri.pRecordOrder = (PRECORDCORE) CMA_END;
1321 ri.pRecordParent = (PRECORDCORE) NULL;
1322 ri.zOrder = (ULONG) CMA_TOP;
1323 ri.cRecordsInsert = recsNeeded;
1324 ri.fInvalidateRecord = FALSE;
1325
1326 if (!WinSendMsg(hwndRight, CM_INSERTRECORD,
1327 MPFROMP(pcirFirst), MPFROMP(&ri))) {
1328 Win_Error(hwndRight, cmp->hwnd, pszSrcFile, __LINE__, "CM_INSERTRECORD");
1329 RemoveCnrItems(hwndLeft, NULL, 0, CMA_FREE | CMA_INVALIDATE);
1330 FreeCnrItemList(hwndRight, pcirFirst);
1331 numfilesr = 0;
1332 }
1333
1334 cmp->cmp->totalleft = numfilesl;
1335 cmp->cmp->totalright = numfilesr;
1336
1337 } // if recsNeeded
1338
1339 Deselect(hwndLeft);
1340 Deselect(hwndRight);
1341
1342 if (!PostMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID))
1343 WinSendMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID);
1344 notified = TRUE;
1345
1346 if (filesl)
1347 FreeList((CHAR **)filesl); // Must have failed to create container
1348 if (filesr)
1349 FreeList((CHAR **)filesr);
1350
1351 WinDestroyMsgQueue(hmq);
1352 }
1353 DecrThreadUsage();
1354 WinTerminate(hab);
1355 }
1356 if (!notified)
1357 PostMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID);
1358 free(cmp);
1359 DosPostEventSem(CompactSem);
1360}
1361
1362#define hwndLeft (WinWindowFromID(hwnd,COMP_LEFTDIR))
1363#define hwndRight (WinWindowFromID(hwnd,COMP_RIGHTDIR))
1364
1365//=== CompareDlgProc() Compare directories dialog procedure ===
1366
1367MRESULT EXPENTRY CompareDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1368{
1369 COMPARE *cmp;
1370
1371 static HPOINTER hptr = (HPOINTER) 0;
1372
1373 switch (msg) {
1374 case WM_INITDLG:
1375 cmp = (COMPARE *) mp2;
1376 if (!cmp) {
1377 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1378 WinDismissDlg(hwnd, 0);
1379 }
1380 else {
1381 if (!hptr)
1382 hptr = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, COMPARE_ICON);
1383 WinDefDlgProc(hwnd, WM_SETICON, MPFROMLONG(hptr), MPVOID);
1384 cmp->hwnd = hwnd;
1385 WinSetWindowPtr(hwnd, QWL_USER, (PVOID) cmp);
1386 SetCnrCols(hwndLeft, TRUE);
1387 SetCnrCols(hwndRight, TRUE);
1388 WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
1389 WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
1390 PostMsg(hwnd, UM_STRETCH, MPVOID, MPVOID);
1391 {
1392 USHORT ids[] = { COMP_LEFTDIR, COMP_RIGHTDIR, COMP_TOTALLEFT,
1393 COMP_TOTALRIGHT, COMP_SELLEFT, COMP_SELRIGHT,
1394 0
1395 };
1396 INT x;
1397
1398 for (x = 0; ids[x]; x++)
1399 SetPresParams(WinWindowFromID(hwnd, ids[x]),
1400 &RGBGREY,
1401 &RGBBLACK, &RGBBLACK, GetPString(IDS_8HELVTEXT));
1402 }
1403 }
1404 break;
1405
1406 case UM_STRETCH:
1407 {
1408 SWP swp, swpC;
1409 LONG titl, szbx, szby, sz;
1410 HWND hwndActive;
1411
1412 WinQueryWindowPos(hwnd, &swp);
1413 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE))) {
1414 hwndActive = WinQueryFocus(HWND_DESKTOP);
1415 szbx = SysVal(SV_CXSIZEBORDER);
1416 szby = SysVal(SV_CYSIZEBORDER);
1417 titl = SysVal(SV_CYTITLEBAR);
1418 titl += 26;
1419 swp.cx -= (szbx * 2);
1420 sz = (swp.cx / 8);
1421 WinQueryWindowPos(WinWindowFromID(hwnd, COMP_LEFTDIR), &swpC);
1422 WinSetWindowPos(WinWindowFromID(hwnd, COMP_LEFTDIR), HWND_TOP,
1423 szbx + 6,
1424 swpC.y,
1425 (swp.cx / 2) - (szbx + 6),
1426 ((swp.cy - swpC.y) - titl) - szby,
1427 SWP_MOVE | SWP_SIZE);
1428 WinSetWindowPos(WinWindowFromID(hwnd, COMP_RIGHTDIR), HWND_TOP,
1429 (swp.cx / 2) + (szbx + 6),
1430 swpC.y,
1431 (swp.cx / 2) - (szbx + 6),
1432 ((swp.cy - swpC.y) - titl) - szby,
1433 SWP_MOVE | SWP_SIZE);
1434 WinSetWindowPos(WinWindowFromID(hwnd, COMP_TOTALLEFTHDR), HWND_TOP,
1435 szbx + 6,
1436 ((swp.cy - titl) - szby) + 4,
1437 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1438 WinSetWindowPos(WinWindowFromID(hwnd, COMP_TOTALLEFT), HWND_TOP,
1439 sz + (szbx + 6),
1440 ((swp.cy - titl) - szby) + 4,
1441 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1442 WinSetWindowPos(WinWindowFromID(hwnd, COMP_SELLEFTHDR), HWND_TOP,
1443 (sz * 2) + (szbx + 6),
1444 ((swp.cy - titl) - szby) + 4,
1445 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1446 WinSetWindowPos(WinWindowFromID(hwnd, COMP_SELLEFT), HWND_TOP,
1447 (sz * 3) + (szbx + 6),
1448 ((swp.cy - titl) - szby) + 4,
1449 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1450 WinSetWindowPos(WinWindowFromID(hwnd, COMP_TOTALRIGHTHDR), HWND_TOP,
1451 (sz * 4) + (szbx + 6),
1452 ((swp.cy - titl) - szby) + 4,
1453 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1454 WinSetWindowPos(WinWindowFromID(hwnd, COMP_TOTALRIGHT), HWND_TOP,
1455 (sz * 5) + (szbx + 6),
1456 ((swp.cy - titl) - szby) + 4,
1457 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1458 WinSetWindowPos(WinWindowFromID(hwnd, COMP_SELRIGHTHDR), HWND_TOP,
1459 (sz * 6) + (szbx + 6),
1460 ((swp.cy - titl) - szby) + 4,
1461 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1462 WinSetWindowPos(WinWindowFromID(hwnd, COMP_SELRIGHT), HWND_TOP,
1463 (sz * 7) + (szbx + 6),
1464 ((swp.cy - titl) - szby) + 4,
1465 sz - (szbx + 6), 20, SWP_MOVE | SWP_SIZE);
1466 PaintRecessedWindow(WinWindowFromID(hwnd, COMP_TOTALLEFT),
1467 (HPS) 0, FALSE, FALSE);
1468 PaintRecessedWindow(WinWindowFromID(hwnd, COMP_SELLEFT),
1469 (HPS) 0, FALSE, FALSE);
1470 PaintRecessedWindow(WinWindowFromID(hwnd, COMP_TOTALRIGHT),
1471 (HPS) 0, FALSE, FALSE);
1472 PaintRecessedWindow(WinWindowFromID(hwnd, COMP_SELRIGHT),
1473 (HPS) 0, FALSE, FALSE);
1474 PaintRecessedWindow(hwndLeft, (HPS) 0,
1475 (hwndActive == hwndLeft), TRUE);
1476 PaintRecessedWindow(hwndRight, (HPS) 0,
1477 (hwndActive == hwndRight), TRUE);
1478 }
1479 }
1480 return 0;
1481
1482 case WM_ADJUSTWINDOWPOS:
1483 PostMsg(hwnd, UM_STRETCH, MPVOID, MPVOID);
1484 break;
1485
1486 case UM_SETUP:
1487 {
1488 CNRINFO cnri;
1489 BOOL tempsubj;
1490
1491 cmp = INSTDATA(hwnd);
1492 if (cmp) {
1493 cmp->dcd.size = sizeof(DIRCNRDATA);
1494 cmp->dcd.type = DIR_FRAME;
1495 cmp->dcd.hwndFrame = hwnd;
1496 cmp->dcd.hwndClient = hwnd;
1497 cmp->dcd.mask.attrFile = (FILE_DIRECTORY | FILE_ARCHIVED |
1498 FILE_READONLY | FILE_SYSTEM | FILE_HIDDEN);
1499 LoadDetailsSwitches("DirCmp", &cmp->dcd);
1500 cmp->dcd.detailslongname = FALSE;
1501 cmp->dcd.detailsicon = FALSE; // TRUE;
1502 }
1503 memset(&cnri, 0, sizeof(CNRINFO));
1504 cnri.cb = sizeof(CNRINFO);
1505 WinSendDlgItemMsg(hwnd, COMP_LEFTDIR, CM_QUERYCNRINFO,
1506 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1507 cnri.flWindowAttr |= (CA_OWNERDRAW | CV_MINI);
1508 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 68;
1509 WinSendDlgItemMsg(hwnd, COMP_LEFTDIR, CM_SETCNRINFO, MPFROMP(&cnri),
1510 MPFROMLONG(CMA_FLWINDOWATTR | CMA_XVERTSPLITBAR));
1511 memset(&cnri, 0, sizeof(CNRINFO));
1512 cnri.cb = sizeof(CNRINFO);
1513 WinSendDlgItemMsg(hwnd, COMP_RIGHTDIR, CM_QUERYCNRINFO,
1514 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1515 cnri.flWindowAttr |= (CA_OWNERDRAW | CV_MINI);
1516 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 54;
1517 WinSendDlgItemMsg(hwnd, COMP_RIGHTDIR, CM_SETCNRINFO, MPFROMP(&cnri),
1518 MPFROMLONG(CMA_FLWINDOWATTR | CMA_XVERTSPLITBAR));
1519 AdjustCnrColRO(hwndLeft, GetPString(IDS_FILENAMECOLTEXT), TRUE, FALSE);
1520 AdjustCnrColRO(hwndLeft, GetPString(IDS_LONGNAMECOLTEXT), TRUE, FALSE);
1521 AdjustCnrColRO(hwndRight, GetPString(IDS_FILENAMECOLTEXT), TRUE, FALSE);
1522 AdjustCnrColRO(hwndRight, GetPString(IDS_LONGNAMECOLTEXT), TRUE, FALSE);
1523 AdjustCnrColsForPref(hwndLeft, cmp->leftdir, &cmp->dcd, TRUE);
1524 tempsubj = cmp->dcd.detailssubject;
1525 cmp->dcd.detailssubject = FALSE;
1526 AdjustCnrColsForPref(hwndRight, cmp->rightdir, &cmp->dcd, TRUE);
1527 if (*cmp->rightlist) {
1528 AdjustCnrColVis(hwndRight, GetPString(IDS_LADATECOLTEXT), FALSE,
1529 FALSE);
1530 AdjustCnrColVis(hwndRight, GetPString(IDS_LATIMECOLTEXT), FALSE,
1531 FALSE);
1532 AdjustCnrColVis(hwndRight, GetPString(IDS_CRDATECOLTEXT), FALSE,
1533 FALSE);
1534 AdjustCnrColVis(hwndRight, GetPString(IDS_CRTIMECOLTEXT), FALSE,
1535 FALSE);
1536 }
1537 cmp->dcd.detailssubject = tempsubj;
1538 }
1539 return 0;
1540
1541 case WM_DRAWITEM:
1542 if (mp2) {
1543 POWNERITEM pown = (POWNERITEM)mp2;
1544 PCNRDRAWITEMINFO pcown;
1545 PCNRITEM pci;
1546
1547 pcown = (PCNRDRAWITEMINFO)pown->hItem;
1548 if (pcown) {
1549 pci = (PCNRITEM) pcown->pRecord;
1550 // 01 Aug 07 SHL if field null or blank, we draw
1551 // fixme to know why - probably to optimize and bypass draw?
1552 if (pci && (INT)pci != -1 && !*pci->pszFileName)
1553 return MRFROMLONG(TRUE);
1554 }
1555 }
1556 return 0;
1557
1558 case UM_CONTAINERHWND:
1559 WinSetDlgItemText(hwnd, COMP_NOTE, GetPString(IDS_COMPHOLDBLDLISTTEXT));
1560 return 0;
1561
1562 case UM_CONTAINERDIR:
1563 WinSetDlgItemText(hwnd, COMP_NOTE, GetPString(IDS_COMPHOLDFILLCNRTEXT));
1564 return 0;
1565
1566 case UM_CONTAINER_FILLED:
1567 cmp = INSTDATA(hwnd);
1568 if (!cmp) {
1569 Runtime_Error(pszSrcFile, __LINE__, "pCompare NULL");
1570 WinDismissDlg(hwnd, 0);
1571 }
1572 else {
1573 CHAR s[81];
1574
1575 cmp->filling = FALSE;
1576 WinEnableWindow(hwndLeft, TRUE);
1577 WinEnableWindow(hwndRight, TRUE);
1578 WinEnableWindowUpdate(hwndLeft, TRUE);
1579 WinEnableWindowUpdate(hwndRight, TRUE);
1580 sprintf(s, " %d", cmp->totalleft);
1581 WinSetDlgItemText(hwnd, COMP_TOTALLEFT, s);
1582 sprintf(s, " %d", cmp->totalright);
1583 WinSetDlgItemText(hwnd, COMP_TOTALRIGHT, s);
1584 sprintf(s, " %d", cmp->selleft);
1585 WinSetDlgItemText(hwnd, COMP_SELLEFT, s);
1586 sprintf(s, " %d", cmp->selright);
1587 WinSetDlgItemText(hwnd, COMP_SELRIGHT, s);
1588 WinEnableWindow(WinWindowFromID(hwnd, DID_OK), TRUE);
1589 WinEnableWindow(WinWindowFromID(hwnd, DID_CANCEL), TRUE);
1590 WinEnableWindow(WinWindowFromID(hwnd, COMP_COLLECT), TRUE);
1591 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBOTH), TRUE);
1592 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTONE), TRUE);
1593 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTNEWER), TRUE);
1594 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTOLDER), TRUE);
1595 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBIGGER), TRUE);
1596 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSMALLER), TRUE);
1597 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBOTH), TRUE);
1598 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTONE), TRUE);
1599 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTNEWER), TRUE);
1600 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTOLDER), TRUE);
1601 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBIGGER), TRUE);
1602 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTSMALLER), TRUE);
1603 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTALL), TRUE);
1604 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAMECONTENT), TRUE);
1605 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTIDENTICAL), TRUE);
1606 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAME), TRUE);
1607 WinEnableWindow(WinWindowFromID(hwnd, IDM_INVERT), TRUE);
1608 WinEnableWindow(WinWindowFromID(hwnd, COMP_SETDIRS), TRUE);
1609 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETELEFT), TRUE);
1610 WinEnableWindow(WinWindowFromID(hwnd, COMP_FILTER), TRUE);
1611 if (!*cmp->rightlist) {
1612 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYLEFT), TRUE);
1613 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVELEFT), TRUE);
1614 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETERIGHT), TRUE);
1615 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYRIGHT), TRUE);
1616 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVERIGHT), TRUE);
1617 }
1618 WinEnableWindow(WinWindowFromID(hwnd, COMP_INCLUDESUBDIRS), TRUE);
1619 if (*cmp->dcd.mask.szMask)
1620 WinSetDlgItemText(hwnd, COMP_NOTE,
1621 GetPString(IDS_COMPREADYFILTEREDTEXT));
1622 else
1623 WinSetDlgItemText(hwnd, COMP_NOTE, GetPString(IDS_COMPREADYTEXT));
1624 }
1625 break;
1626
1627 case WM_INITMENU:
1628 cmp = INSTDATA(hwnd);
1629 if (cmp) {
1630 switch (SHORT1FROMMP(mp1)) {
1631 case IDM_COMMANDSMENU:
1632 SetupCommandMenu(cmp->dcd.hwndLastMenu, hwnd);
1633 break;
1634 }
1635 }
1636 break;
1637
1638 case WM_MENUEND:
1639 cmp = INSTDATA(hwnd);
1640 if (cmp) {
1641 if ((HWND) mp2 == cmp->dcd.hwndLastMenu) {
1642 MarkAll(hwndLeft, TRUE, FALSE, TRUE);
1643 MarkAll(hwndRight, TRUE, FALSE, TRUE);
1644 WinDestroyWindow(cmp->dcd.hwndLastMenu);
1645 cmp->dcd.hwndLastMenu = (HWND) 0;
1646 }
1647 }
1648 break;
1649
1650 case WM_CONTROL:
1651 switch (SHORT1FROMMP(mp1)) {
1652 case COMP_INCLUDESUBDIRS:
1653 switch (SHORT2FROMMP(mp1)) {
1654 case BN_CLICKED:
1655 cmp = INSTDATA(hwnd);
1656 if (cmp)
1657 *cmp->rightlist = 0;
1658 PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
1659 PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
1660 break;
1661 }
1662 break;
1663 case COMP_HIDENOTSELECTED:
1664 switch (SHORT2FROMMP(mp1)) {
1665 case BN_CLICKED:
1666 WinSendMsg(hwnd, UM_HIDENOTSELECTED, MPVOID, MPVOID);
1667 break;
1668 }
1669 break;
1670
1671 case COMP_LEFTDIR:
1672 case COMP_RIGHTDIR:
1673 switch (SHORT2FROMMP(mp1)) {
1674 case CN_KILLFOCUS:
1675 PaintRecessedWindow(WinWindowFromID(hwnd, SHORT1FROMMP(mp1)),
1676 (HPS) 0, FALSE, TRUE);
1677 break;
1678
1679 case CN_SETFOCUS:
1680 PaintRecessedWindow(WinWindowFromID(hwnd, SHORT1FROMMP(mp1)),
1681 (HPS) 0, TRUE, TRUE);
1682 break;
1683
1684 case CN_ENTER:
1685 if (mp2) {
1686
1687 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
1688 HWND hwndCnr = WinWindowFromID(hwnd, SHORT1FROMMP(mp1));
1689
1690 SetShiftState();
1691 if (pci) {
1692 if (pci->rc.flRecordAttr & CRA_INUSE || !pci || !*pci->pszFileName)
1693 break;
1694 WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
1695 MPFROM2SHORT(TRUE, CRA_INUSE));
1696 if (pci->attrFile & FILE_DIRECTORY) {
1697 if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT))
1698 OpenObject(pci->pszFileName, Settings, hwnd);
1699 else
1700 OpenObject(pci->pszFileName, Default, hwnd);
1701 }
1702 else
1703 DefaultViewKeys(hwnd, hwnd, HWND_DESKTOP, NULL,
1704 pci->pszFileName);
1705 WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
1706 MPFROMP(pci),
1707 MPFROM2SHORT(FALSE, CRA_INUSE |
1708 ((fUnHilite) ? CRA_SELECTED : 0)));
1709 }
1710 }
1711 break;
1712
1713 case CN_CONTEXTMENU:
1714 cmp = INSTDATA(hwnd);
1715 if (cmp) {
1716
1717 PCNRITEM pci = (PCNRITEM) mp2;
1718 USHORT id = COMP_CNRMENU;
1719
1720 if (cmp->dcd.hwndLastMenu)
1721 WinDestroyWindow(cmp->dcd.hwndLastMenu);
1722 cmp->dcd.hwndLastMenu = (HWND) 0;
1723 cmp->hwndCalling = WinWindowFromID(hwnd, SHORT1FROMMP(mp1));
1724 if (pci) {
1725 if (!pci || !*pci->pszFileName || *cmp->rightlist)
1726 break;
1727 id = COMP_MENU;
1728 WinSendMsg(cmp->hwndCalling, CM_SETRECORDEMPHASIS,
1729 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
1730 }
1731 cmp->dcd.hwndLastMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
1732 if (cmp->dcd.hwndLastMenu) {
1733 if (id == COMP_CNRMENU) {
1734 if (SHORT1FROMMP(mp1) == COMP_RIGHTDIR)
1735 WinSendMsg(cmp->dcd.hwndLastMenu, MM_DELETEITEM,
1736 MPFROM2SHORT(IDM_SHOWSUBJECT, FALSE), MPVOID);
1737 SetDetailsSwitches(cmp->dcd.hwndLastMenu, &cmp->dcd);
1738 if (SHORT1FROMMP(mp1) == COMP_LEFTDIR)
1739 WinSendMsg(cmp->dcd.hwndLastMenu, MM_DELETEITEM,
1740 MPFROM2SHORT(IDM_LOADLISTFILE, 0), MPVOID);
1741 else if (*cmp->rightlist)
1742 WinSendMsg(cmp->dcd.hwndLastMenu, MM_DELETEITEM,
1743 MPFROM2SHORT(IDM_SAVELISTFILE, 0), MPVOID);
1744 }
1745 PopupMenu(hwnd, hwnd, cmp->dcd.hwndLastMenu);
1746 }
1747 }
1748 break;
1749
1750 case CN_INITDRAG:
1751 cmp = INSTDATA(hwnd);
1752 if (*cmp->rightlist && SHORT1FROMMP(mp1) == COMP_RIGHTDIR)
1753 break;
1754 DoFileDrag(WinWindowFromID(hwnd, SHORT1FROMMP(mp1)),
1755 (HWND) 0, mp2, NULL, NULL, TRUE);
1756 break;
1757
1758 case CN_BEGINEDIT:
1759 case CN_REALLOCPSZ:
1760 // fixme to be gone - field edits not allowed
1761 Runtime_Error(pszSrcFile, __LINE__,
1762 "CN_BEGINEDIT/CN_REALLOCPSZ unexpected");
1763 break;
1764
1765 case CN_EMPHASIS:
1766 {
1767 PNOTIFYRECORDEMPHASIS pre = mp2;
1768 PCNRITEM pci;
1769
1770 if (pre->fEmphasisMask & CRA_SELECTED) {
1771 pci = (PCNRITEM) pre->pRecord;
1772 if (pci) {
1773 if (!pci || !*pci->pszFileName) {
1774 if (pci->rc.flRecordAttr & CRA_SELECTED)
1775 WinSendDlgItemMsg(hwnd, SHORT1FROMMP(mp1),
1776 CM_SETRECORDEMPHASIS,
1777 MPFROMP(pci),
1778 MPFROM2SHORT(FALSE, CRA_SELECTED));
1779 }
1780 else {
1781
1782 CHAR s[81];
1783
1784 cmp = INSTDATA(hwnd);
1785 if (pci->rc.flRecordAttr & CRA_SELECTED) {
1786 if (SHORT1FROMMP(mp1) == COMP_LEFTDIR)
1787 cmp->selleft++;
1788 else
1789 cmp->selright++;
1790 }
1791 else {
1792 if (SHORT1FROMMP(mp1) == COMP_LEFTDIR) {
1793 if (cmp->selleft)
1794 cmp->selleft--;
1795 }
1796 else {
1797 if (cmp->selright)
1798 cmp->selright--;
1799 }
1800 }
1801 if (SHORT1FROMMP(mp1) == COMP_LEFTDIR) {
1802 if (WinIsWindowEnabled(hwndLeft) || !(cmp->selleft % 50)) {
1803 sprintf(s, " %d", cmp->selleft);
1804 WinSetDlgItemText(hwnd, COMP_SELLEFT, s);
1805 }
1806 }
1807 else {
1808 if (WinIsWindowEnabled(hwndRight) || !(cmp->selright % 50)) {
1809 sprintf(s, " %d", cmp->selright);
1810 WinSetDlgItemText(hwnd, COMP_SELRIGHT, s);
1811 }
1812 }
1813 }
1814 }
1815 }
1816 }
1817 break;
1818
1819 case CN_SCROLL:
1820 cmp = INSTDATA(hwnd);
1821 if (!cmp->forcescroll) {
1822
1823 PNOTIFYSCROLL pns = mp2;
1824
1825 if (pns->fScroll & CMA_VERTICAL) {
1826 cmp->forcescroll = TRUE;
1827 WinSendDlgItemMsg(hwnd, (SHORT1FROMMP(mp1) == COMP_LEFTDIR) ?
1828 COMP_RIGHTDIR : COMP_LEFTDIR,
1829 CM_SCROLLWINDOW, MPFROMSHORT(CMA_VERTICAL),
1830 MPFROMLONG(pns->lScrollInc));
1831 cmp->forcescroll = FALSE;
1832 }
1833 }
1834 break;
1835 }
1836 break; // COMP_RIGHTDIR
1837 }
1838 return 0; // WM_CONTROL
1839
1840 case UM_SETDIR:
1841 cmp = INSTDATA(hwnd);
1842 if (cmp) {
1843
1844 COMPARE *forthread;
1845 CNRINFO cnri;
1846
1847 cmp->includesubdirs = WinQueryButtonCheckstate(hwnd,
1848 COMP_INCLUDESUBDIRS);
1849 memset(&cnri, 0, sizeof(CNRINFO));
1850 cnri.cb = sizeof(CNRINFO);
1851 cnri.pszCnrTitle = cmp->leftdir;
1852 cnri.flWindowAttr = CV_DETAIL | CV_MINI |
1853 CA_CONTAINERTITLE | CA_TITLESEPARATOR |
1854 CA_DETAILSVIEWTITLES | CA_OWNERDRAW;
1855 WinSendDlgItemMsg(hwnd, COMP_LEFTDIR, CM_SETCNRINFO, MPFROMP(&cnri),
1856 MPFROMLONG(CMA_CNRTITLE | CMA_FLWINDOWATTR));
1857 cnri.pszCnrTitle = cmp->rightdir;
1858 WinSendDlgItemMsg(hwnd, COMP_RIGHTDIR, CM_SETCNRINFO, MPFROMP(&cnri),
1859 MPFROMLONG(CMA_CNRTITLE | CMA_FLWINDOWATTR));
1860 WinCheckButton(hwnd, COMP_HIDENOTSELECTED, 0);
1861 cmp->filling = TRUE;
1862 forthread = xmalloc(sizeof(COMPARE), pszSrcFile, __LINE__);
1863 if (!forthread)
1864 WinDismissDlg(hwnd, 0);
1865 else {
1866 *forthread = *cmp;
1867 forthread->cmp = cmp;
1868 if (_beginthread(FillCnrsThread, NULL, 122880, (PVOID) forthread) ==
1869 -1) {
1870 Runtime_Error(pszSrcFile, __LINE__,
1871 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1872 WinDismissDlg(hwnd, 0);
1873 free(forthread);
1874 }
1875 else {
1876 WinEnableWindowUpdate(hwndLeft, FALSE);
1877 WinEnableWindowUpdate(hwndRight, FALSE);
1878 cmp->selleft = cmp->selright = 0;
1879 WinSetDlgItemText(hwnd, COMP_SELLEFT, "0");
1880 WinSetDlgItemText(hwnd, COMP_SELRIGHT, "0");
1881 WinSetDlgItemText(hwnd, COMP_TOTALLEFT, "0");
1882 WinSetDlgItemText(hwnd, COMP_TOTALRIGHT, "0");
1883 WinSetDlgItemText(hwnd, COMP_NOTE,
1884 GetPString(IDS_COMPHOLDREADDISKTEXT));
1885 WinEnableWindow(hwndRight, FALSE);
1886 WinEnableWindow(hwndLeft, FALSE);
1887 WinEnableWindow(WinWindowFromID(hwnd, DID_OK), FALSE);
1888 WinEnableWindow(WinWindowFromID(hwnd, DID_CANCEL), FALSE);
1889 WinEnableWindow(WinWindowFromID(hwnd, COMP_COLLECT), FALSE);
1890 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBOTH), FALSE);
1891 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTONE), FALSE);
1892 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTNEWER), FALSE);
1893 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTOLDER), FALSE);
1894 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBIGGER), FALSE);
1895 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSMALLER), FALSE);
1896 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBOTH), FALSE);
1897 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTONE), FALSE);
1898 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTNEWER), FALSE);
1899 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTOLDER), FALSE);
1900 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBIGGER), FALSE);
1901 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTSMALLER), FALSE);
1902 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTALL), FALSE);
1903 WinEnableWindow(WinWindowFromID(hwnd, COMP_INCLUDESUBDIRS), FALSE);
1904 WinEnableWindow(WinWindowFromID(hwnd, COMP_SETDIRS), FALSE);
1905 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETELEFT), FALSE);
1906 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETERIGHT), FALSE);
1907 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYLEFT), FALSE);
1908 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVELEFT), FALSE);
1909 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYRIGHT), FALSE);
1910 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVERIGHT), FALSE);
1911 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAMECONTENT),
1912 FALSE);
1913 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTIDENTICAL), FALSE);
1914 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAME), FALSE);
1915 WinEnableWindow(WinWindowFromID(hwnd, IDM_INVERT), FALSE);
1916 WinEnableWindow(WinWindowFromID(hwnd, COMP_FILTER), FALSE);
1917 }
1918 }
1919 }
1920 return 0;
1921
1922 case UM_FILTER:
1923 cmp = INSTDATA(hwnd);
1924 if (cmp) {
1925 if (mp1) {
1926 DosEnterCritSec();
1927 SetMask((CHAR *) mp1, &cmp->dcd.mask);
1928 DosExitCritSec();
1929 }
1930 cmp->dcd.suspendview = 1;
1931 WinSendMsg(hwndLeft, CM_FILTER, MPFROMP(Filter),
1932 MPFROMP(&cmp->dcd.mask));
1933 WinSendMsg(hwndRight, CM_FILTER, MPFROMP(Filter),
1934 MPFROMP(&cmp->dcd.mask));
1935 cmp->dcd.suspendview = 0;
1936 if (*cmp->dcd.mask.szMask)
1937 WinSetDlgItemText(hwnd, COMP_NOTE,
1938 GetPString(IDS_COMPREADYFILTEREDTEXT));
1939 else
1940 WinSetDlgItemText(hwnd, COMP_NOTE, GetPString(IDS_COMPREADYTEXT));
1941 }
1942 return 0;
1943
1944 case UM_HIDENOTSELECTED:
1945 cmp = INSTDATA(hwnd);
1946 if (cmp) {
1947 USHORT wantHide = WinQueryButtonCheckstate(hwnd,
1948 COMP_HIDENOTSELECTED);
1949
1950 cmp->dcd.suspendview = 1;
1951 if (wantHide) {
1952 BOOL needRefresh = FALSE;
1953 HWND hwndl = WinWindowFromID(cmp->hwnd, COMP_LEFTDIR);
1954 HWND hwndr = WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR);
1955 PCNRITEM pcil = WinSendMsg(hwndl, CM_QUERYRECORD, MPVOID,
1956 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
1957 PCNRITEM pcir = WinSendMsg(hwndr, CM_QUERYRECORD, MPVOID,
1958 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
1959
1960 while (pcil && (INT) pcil != -1 && pcir && (INT) pcir != -1) {
1961 if (~pcil->rc.flRecordAttr & CRA_SELECTED &&
1962 ~pcir->rc.flRecordAttr & CRA_SELECTED) {
1963 pcil->rc.flRecordAttr |= CRA_FILTERED;
1964 pcir->rc.flRecordAttr |= CRA_FILTERED;
1965 needRefresh = TRUE;
1966 }
1967 pcil = WinSendMsg(hwndl, CM_QUERYRECORD, MPFROMP(pcil),
1968 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
1969 pcir = WinSendMsg(hwndr, CM_QUERYRECORD, MPFROMP(pcir),
1970 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
1971 } // while
1972 if (needRefresh) {
1973 WinSendMsg(hwndl, CM_INVALIDATERECORD,
1974 MPVOID, MPFROM2SHORT(0, CMA_REPOSITION));
1975 WinSendMsg(hwndr, CM_INVALIDATERECORD,
1976 MPVOID, MPFROM2SHORT(0, CMA_REPOSITION));
1977 }
1978 }
1979 else {
1980 WinSendMsg(hwndLeft, CM_FILTER, MPFROMP(Filter),
1981 MPFROMP(&cmp->dcd.mask));
1982 WinSendMsg(hwndRight, CM_FILTER, MPFROMP(Filter),
1983 MPFROMP(&cmp->dcd.mask));
1984 }
1985 cmp->dcd.suspendview = 0;
1986 if (*cmp->dcd.mask.szMask)
1987 WinSetDlgItemText(hwnd, COMP_NOTE,
1988 GetPString(IDS_COMPREADYFILTEREDTEXT));
1989 else
1990 WinSetDlgItemText(hwnd, COMP_NOTE, GetPString(IDS_COMPREADYTEXT));
1991 }
1992 return 0;
1993
1994 case WM_COMMAND:
1995 switch (SHORT1FROMMP(mp1)) {
1996 case IDM_COMPARE:
1997 cmp = INSTDATA(hwnd);
1998 if (cmp) {
1999
2000 PCNRITEM pci;
2001 CHAR ofile[CCHMAXPATH];
2002
2003 pci = (PCNRITEM) WinSendMsg(cmp->hwndCalling,
2004 CM_QUERYRECORDEMPHASIS,
2005 MPFROMLONG(CMA_FIRST),
2006 MPFROMSHORT(CRA_CURSORED));
2007 // 01 Aug 07 SHL
2008 if (pci && *pci->pszFileName) {
2009 if (cmp->hwndCalling == hwndLeft)
2010 strcpy(ofile, cmp->rightdir);
2011 else
2012 strcpy(ofile, cmp->leftdir);
2013 if (ofile[strlen(ofile) - 1] != '\\')
2014 strcat(ofile, "\\");
2015 strcat(ofile, pci->pszDisplayName);
2016 if (*compare) {
2017 CHAR *fakelist[3];
2018 fakelist[0] = pci->pszFileName;
2019 fakelist[1] = ofile;
2020 fakelist[2] = NULL;
2021 ExecOnList(hwnd, compare,
2022 WINDOWED | SEPARATEKEEP, NULL, fakelist, NULL);
2023 }
2024 else {
2025 FCOMPARE fc;
2026 memset(&fc, 0, sizeof(fc));
2027 fc.size = sizeof(fc);
2028 fc.hwndParent = hwnd;
2029 strcpy(fc.file1, pci->pszFileName);
2030 strcpy(fc.file2, ofile);
2031 WinDlgBox(HWND_DESKTOP, hwnd,
2032 CFileDlgProc, FM3ModHandle, FCMP_FRAME, (PVOID) & fc);
2033 }
2034 }
2035 }
2036 break;
2037
2038 case COMP_FILTER:
2039 case IDM_FILTER:
2040 cmp = INSTDATA(hwnd);
2041 if (cmp) {
2042
2043 BOOL empty = FALSE;
2044 PCNRITEM pci;
2045 CHAR *p;
2046 BOOL temp;
2047
2048 if (!*cmp->dcd.mask.szMask) {
2049 empty = TRUE;
2050 temp = fSelectedAlways;
2051 fSelectedAlways = TRUE;
2052 pci = (PCNRITEM)CurrentRecord(hwnd);
2053 fSelectedAlways = temp;
2054 // 01 Aug 07 SHL
2055 if (pci && ~pci->attrFile & FILE_DIRECTORY) {
2056 p = strrchr(pci->pszFileName, '\\');
2057 if (p) {
2058 p++;
2059 strcpy(cmp->dcd.mask.szMask, p);
2060 }
2061 }
2062 }
2063 cmp->dcd.mask.fNoAttribs = TRUE;
2064 cmp->dcd.mask.attrFile = ALLATTRS;
2065 cmp->dcd.mask.antiattr = 0;
2066 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2067 FM3ModHandle, MSK_FRAME, MPFROMP(&cmp->dcd.mask))) {
2068 cmp->dcd.mask.attrFile = ALLATTRS;
2069 cmp->dcd.mask.antiattr = 0;
2070 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
2071 }
2072 else if (empty) {
2073 *cmp->dcd.mask.szMask = 0;
2074 cmp->dcd.mask.attrFile = ALLATTRS;
2075 cmp->dcd.mask.antiattr = 0;
2076 }
2077 }
2078 break;
2079
2080 case IDM_SHOWSUBJECT:
2081 case IDM_SHOWEAS:
2082 case IDM_SHOWSIZE:
2083 case IDM_SHOWLWDATE:
2084 case IDM_SHOWLWTIME:
2085 case IDM_SHOWLADATE:
2086 case IDM_SHOWLATIME:
2087 case IDM_SHOWCRDATE:
2088 case IDM_SHOWCRTIME:
2089 case IDM_SHOWATTR:
2090 cmp = INSTDATA(hwnd);
2091 if (cmp) {
2092
2093 DIRCNRDATA dcd1;
2094 BOOL tempsubj;
2095
2096 dcd1 = cmp->dcd;
2097 AdjustDetailsSwitches(hwndLeft,
2098 (HWND) 0, SHORT1FROMMP(mp1),
2099 cmp->leftdir, "DirCmp", &cmp->dcd, TRUE);
2100 tempsubj = cmp->dcd.detailssubject;
2101 cmp->dcd = dcd1;
2102 cmp->dcd.detailssubject = FALSE;
2103 AdjustDetailsSwitches(hwndRight,
2104 cmp->dcd.hwndLastMenu, SHORT1FROMMP(mp1),
2105 cmp->rightdir, "DirCmp", &cmp->dcd, TRUE);
2106 cmp->dcd.detailssubject = tempsubj;
2107 }
2108 break;
2109
2110 case IDM_LOADLISTFILE:
2111 cmp = INSTDATA(hwnd);
2112 if (cmp) {
2113
2114 CHAR fullname[CCHMAXPATH];
2115
2116 strcpy(fullname, "*.PMD");
2117 if (insert_filename(HWND_DESKTOP, fullname, TRUE, FALSE) &&
2118 *fullname && !strchr(fullname, '*') && !strchr(fullname, '?')) {
2119 strcpy(cmp->rightlist, fullname);
2120 PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
2121 PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
2122 }
2123 }
2124 break;
2125
2126 case IDM_SAVELISTFILE:
2127 cmp = INSTDATA(hwnd);
2128 if (cmp) {
2129
2130 SNAPSTUFF *sf;
2131 CHAR fullname[CCHMAXPATH];
2132
2133 strcpy(fullname, "*.PMD");
2134 if (export_filename(HWND_DESKTOP, fullname, 1) && *fullname &&
2135 !strchr(fullname, '*') && !strchr(fullname, '?')) {
2136 sf = xmallocz(sizeof(SNAPSTUFF), pszSrcFile, __LINE__);
2137 if (sf) {
2138 strcpy(sf->filename, fullname);
2139 if (hwndLeft == cmp->hwndCalling)
2140 strcpy(sf->dirname, cmp->leftdir);
2141 else
2142 strcpy(sf->dirname, cmp->rightdir);
2143 sf->recurse = cmp->includesubdirs;
2144 if (_beginthread(StartSnap, NULL, 65536, (PVOID) sf) == -1) {
2145 Runtime_Error(pszSrcFile, __LINE__,
2146 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2147 free(sf);
2148 }
2149 }
2150 }
2151 }
2152 break;
2153
2154 case COMP_SETDIRS:
2155 cmp = INSTDATA(hwnd);
2156 if (cmp) {
2157
2158 WALK2 wa;
2159
2160 memset(&wa, 0, sizeof(wa));
2161 wa.size = sizeof(wa);
2162 strcpy(wa.szCurrentPath1, cmp->leftdir);
2163 strcpy(wa.szCurrentPath2, cmp->rightdir);
2164 if (WinDlgBox(HWND_DESKTOP, hwnd, WalkTwoCmpDlgProc,
2165 FM3ModHandle, WALK2_FRAME,
2166 MPFROMP(&wa)) &&
2167 !IsFile(wa.szCurrentPath1) &&
2168 !IsFile(wa.szCurrentPath2)) {
2169 strcpy(cmp->leftdir, wa.szCurrentPath1);
2170 strcpy(cmp->rightdir, wa.szCurrentPath2);
2171 *cmp->rightlist = 0;
2172 PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
2173 PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
2174 }
2175 }
2176 break;
2177
2178 case COMP_COPYLEFT:
2179 case COMP_MOVELEFT:
2180 case COMP_COPYRIGHT:
2181 case COMP_MOVERIGHT:
2182 case COMP_DELETELEFT:
2183 case COMP_DELETERIGHT:
2184 cmp = INSTDATA(hwnd);
2185 if (cmp) {
2186
2187 COMPARE *forthread;
2188
2189 cmp->filling = TRUE;
2190 forthread = xmalloc(sizeof(COMPARE), pszSrcFile, __LINE__);
2191 if (forthread) {
2192 *forthread = *cmp;
2193 forthread->cmp = cmp;
2194 forthread->action = SHORT1FROMMP(mp1);
2195 if (_beginthread(ActionCnrThread, NULL, 122880, (PVOID) forthread)
2196 == -1) {
2197 Runtime_Error(pszSrcFile, __LINE__,
2198 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2199 free(forthread);
2200 }
2201 else {
2202 WinEnableWindowUpdate(hwndLeft, FALSE);
2203 WinEnableWindowUpdate(hwndRight, FALSE);
2204 switch (SHORT1FROMMP(mp1)) {
2205 case COMP_DELETELEFT:
2206 case COMP_DELETERIGHT:
2207 WinSetDlgItemText(hwnd, COMP_NOTE,
2208 GetPString(IDS_COMPHOLDDELETINGTEXT));
2209 break;
2210 case COMP_MOVELEFT:
2211 case COMP_MOVERIGHT:
2212 WinSetDlgItemText(hwnd, COMP_NOTE,
2213 GetPString(IDS_COMPHOLDMOVINGTEXT));
2214 break;
2215 case COMP_COPYLEFT:
2216 case COMP_COPYRIGHT:
2217 WinSetDlgItemText(hwnd, COMP_NOTE,
2218 GetPString(IDS_COMPHOLDCOPYINGTEXT));
2219 break;
2220 default:
2221 WinSetDlgItemText(hwnd, COMP_NOTE,
2222 GetPString(IDS_COMPHOLDDUNNOTEXT));
2223 break;
2224 }
2225 WinEnableWindow(hwndRight, FALSE);
2226 WinEnableWindow(hwndLeft, FALSE);
2227 WinEnableWindow(WinWindowFromID(hwnd, DID_OK), FALSE);
2228 WinEnableWindow(WinWindowFromID(hwnd, DID_CANCEL), FALSE);
2229 WinEnableWindow(WinWindowFromID(hwnd, COMP_COLLECT), FALSE);
2230 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBOTH), FALSE);
2231 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTONE), FALSE);
2232 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTNEWER), FALSE);
2233 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTOLDER), FALSE);
2234 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBIGGER), FALSE);
2235 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSMALLER), FALSE);
2236 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBOTH), FALSE);
2237 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTONE), FALSE);
2238 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTNEWER), FALSE);
2239 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTOLDER), FALSE);
2240 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBIGGER), FALSE);
2241 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTSMALLER),
2242 FALSE);
2243 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTALL), FALSE);
2244 WinEnableWindow(WinWindowFromID(hwnd, COMP_INCLUDESUBDIRS),
2245 FALSE);
2246 WinEnableWindow(WinWindowFromID(hwnd, COMP_SETDIRS), FALSE);
2247 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETELEFT), FALSE);
2248 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETERIGHT), FALSE);
2249 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYLEFT), FALSE);
2250 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVELEFT), FALSE);
2251 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYRIGHT), FALSE);
2252 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVERIGHT), FALSE);
2253 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAMECONTENT),
2254 FALSE);
2255 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTIDENTICAL),
2256 FALSE);
2257 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAME), FALSE);
2258 WinEnableWindow(WinWindowFromID(hwnd, IDM_INVERT), FALSE);
2259 WinEnableWindow(WinWindowFromID(hwnd, COMP_FILTER), FALSE);
2260 }
2261 }
2262 }
2263 break;
2264
2265 case DID_OK:
2266 WinDismissDlg(hwnd, 0);
2267 break;
2268 case DID_CANCEL:
2269 WinDismissDlg(hwnd, 1);
2270 break;
2271
2272 case IDM_HELP:
2273 if (hwndHelp)
2274 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
2275 MPFROM2SHORT(HELP_COMPARE, 0), MPFROMSHORT(HM_RESOURCEID));
2276 break;
2277
2278 case IDM_DESELECTALL:
2279 case IDM_SELECTNEWER:
2280 case IDM_SELECTOLDER:
2281 case IDM_SELECTBIGGER:
2282 case IDM_SELECTSMALLER:
2283 case IDM_DESELECTNEWER:
2284 case IDM_DESELECTOLDER:
2285 case IDM_DESELECTBIGGER:
2286 case IDM_DESELECTSMALLER:
2287 case IDM_DESELECTONE:
2288 case IDM_DESELECTBOTH:
2289 case IDM_SELECTBOTH:
2290 case IDM_SELECTONE:
2291 case IDM_SELECTSAMECONTENT:
2292 case IDM_SELECTIDENTICAL: // Name, size and time
2293 case IDM_SELECTSAME: // Name and size
2294 case IDM_INVERT:
2295 cmp = INSTDATA(hwnd);
2296 if (!cmp)
2297 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2298 else {
2299 COMPARE *forthread;
2300
2301 cmp->filling = TRUE;
2302 forthread = xmalloc(sizeof(COMPARE), pszSrcFile, __LINE__);
2303 if (forthread) {
2304 *forthread = *cmp;
2305 forthread->cmp = cmp;
2306 forthread->action = SHORT1FROMMP(mp1);
2307 if (_beginthread(SelectCnrsThread, NULL, 65536, (PVOID) forthread)
2308 == -1) {
2309 Runtime_Error(pszSrcFile, __LINE__,
2310 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2311 free(forthread);
2312 }
2313 else {
2314 WinEnableWindowUpdate(hwndLeft, FALSE);
2315 WinEnableWindowUpdate(hwndRight, FALSE);
2316 switch (SHORT1FROMMP(mp1)) {
2317 case IDM_DESELECTALL:
2318 case IDM_DESELECTNEWER:
2319 case IDM_DESELECTOLDER:
2320 case IDM_DESELECTBIGGER:
2321 case IDM_DESELECTSMALLER:
2322 case IDM_DESELECTONE:
2323 case IDM_DESELECTBOTH:
2324 WinSetDlgItemText(hwnd, COMP_NOTE,
2325 GetPString(IDS_COMPHOLDDESELTEXT));
2326 break;
2327 case IDM_INVERT:
2328 WinSetDlgItemText(hwnd, COMP_NOTE,
2329 GetPString(IDS_COMPHOLDINVERTTEXT));
2330 break;
2331 default:
2332 WinSetDlgItemText(hwnd, COMP_NOTE,
2333 GetPString(IDS_COMPHOLDSELTEXT));
2334 break;
2335 }
2336 WinEnableWindow(hwndRight, FALSE);
2337 WinEnableWindow(hwndLeft, FALSE);
2338 WinEnableWindow(WinWindowFromID(hwnd, DID_OK), FALSE);
2339 WinEnableWindow(WinWindowFromID(hwnd, DID_CANCEL), FALSE);
2340 WinEnableWindow(WinWindowFromID(hwnd, COMP_COLLECT), FALSE);
2341 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBOTH), FALSE);
2342 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTONE), FALSE);
2343 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTNEWER), FALSE);
2344 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTOLDER), FALSE);
2345 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTBIGGER), FALSE);
2346 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSMALLER), FALSE);
2347 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBOTH), FALSE);
2348 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTONE), FALSE);
2349 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTNEWER), FALSE);
2350 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTOLDER), FALSE);
2351 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTBIGGER), FALSE);
2352 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTSMALLER),
2353 FALSE);
2354 WinEnableWindow(WinWindowFromID(hwnd, IDM_DESELECTALL), FALSE);
2355 WinEnableWindow(WinWindowFromID(hwnd, COMP_INCLUDESUBDIRS),
2356 FALSE);
2357 WinEnableWindow(WinWindowFromID(hwnd, COMP_SETDIRS), FALSE);
2358 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETELEFT), FALSE);
2359 WinEnableWindow(WinWindowFromID(hwnd, COMP_DELETERIGHT), FALSE);
2360 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYLEFT), FALSE);
2361 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVELEFT), FALSE);
2362 WinEnableWindow(WinWindowFromID(hwnd, COMP_COPYRIGHT), FALSE);
2363 WinEnableWindow(WinWindowFromID(hwnd, COMP_MOVERIGHT), FALSE);
2364 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAMECONTENT),
2365 FALSE);
2366 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTIDENTICAL),
2367 FALSE);
2368 WinEnableWindow(WinWindowFromID(hwnd, IDM_SELECTSAME), FALSE);
2369 WinEnableWindow(WinWindowFromID(hwnd, IDM_INVERT), FALSE);
2370 WinEnableWindow(WinWindowFromID(hwnd, COMP_FILTER), FALSE);
2371 }
2372 }
2373 }
2374 break;
2375
2376 case COMP_COLLECT:
2377 cmp = INSTDATA(hwnd);
2378 if (cmp) {
2379
2380 CHAR **listl, **listr = NULL;
2381
2382 if (!Collector) {
2383
2384 SWP swp;
2385 HWND hwndC;
2386
2387 if (!fAutoTile && !ParentIsDesktop(hwnd, cmp->hwndParent) &&
2388 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2389 GetNextWindowPos(cmp->hwndParent, &swp, NULL, NULL);
2390 hwndC = StartCollector((fExternalCollector ||
2391 strcmp(realappname, FM3Str)) ?
2392 HWND_DESKTOP : cmp->hwndParent, 4);
2393 if (hwndC) {
2394 if (!fAutoTile && !ParentIsDesktop(hwnd, cmp->hwndParent) &&
2395 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2396 WinSetWindowPos(hwndC, HWND_TOP, swp.x, swp.y,
2397 swp.cx, swp.cy, SWP_MOVE | SWP_SIZE |
2398 SWP_SHOW | SWP_ZORDER);
2399 else if (!ParentIsDesktop(hwnd, cmp->hwndParent) && fAutoTile &&
2400 !strcmp(realappname, FM3Str))
2401 TileChildren(cmp->hwndParent, TRUE);
2402 DosSleep(32); //05 Aug 07 GKY 64
2403 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(COMP_COLLECT, 0), MPVOID);
2404 break;
2405 }
2406 }
2407 else
2408 StartCollector(cmp->hwndParent, 4);
2409 {
2410 BOOL temp;
2411
2412 temp = fSelectedAlways;
2413 fSelectedAlways = TRUE;
2414 listl = BuildList(hwndLeft);
2415 if (!*cmp->rightlist)
2416 listr = BuildList(hwndRight);
2417 fSelectedAlways = temp;
2418 }
2419 if (listl || listr) {
2420 if (Collector) {
2421 if (listl) {
2422 if (!PostMsg(Collector, WM_COMMAND,
2423 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(listl)))
2424 FreeList(listl);
2425 }
2426 if (listr) {
2427 if (!PostMsg(Collector, WM_COMMAND,
2428 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(listr)))
2429 FreeList(listr);
2430 }
2431 WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
2432 QW_PARENT),
2433 QW_PARENT), HWND_TOP, 0, 0, 0, 0,
2434 SWP_ACTIVATE);
2435 }
2436 else {
2437 FreeList(listl);
2438 FreeList(listr);
2439 }
2440 }
2441 }
2442 break;
2443 }
2444 return 0;
2445
2446 case WM_CLOSE:
2447 WinDismissDlg(hwnd, 0);
2448 return 0;
2449
2450 case WM_DESTROY:
2451 cmp = INSTDATA(hwnd);
2452 if (cmp) {
2453 if (cmp->dcd.hwndLastMenu)
2454 WinDestroyWindow(cmp->dcd.hwndLastMenu);
2455 if (cmp->dcd.hwndObject) {
2456 WinSetWindowPtr(cmp->dcd.hwndObject, QWL_USER, (PVOID) NULL);
2457 if (!PostMsg(cmp->dcd.hwndObject, WM_CLOSE, MPVOID, MPVOID))
2458 WinSendMsg(cmp->dcd.hwndObject, WM_CLOSE, MPVOID, MPVOID);
2459 }
2460 free(cmp);
2461 }
2462 EmptyCnr(hwndLeft);
2463 EmptyCnr(hwndRight);
2464 DosPostEventSem(CompactSem);
2465 break;
2466 }
2467 return WinDefDlgProc(hwnd, msg, mp1, mp2);
2468}
Note: See TracBrowser for help on using the repository browser.