source: trunk/dll/comp.c@ 672

Last change on this file since 672 was 574, checked in by Gregg Young, 19 years ago

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