![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to complist.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to complist.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 ! root 1: ! 2: /******************************************************************************\ ! 3: * This is a part of the Microsoft Source Code Samples. ! 4: * Copyright (C) 1993 Microsoft Corporation. ! 5: * All rights reserved. ! 6: * This source code is only intended as a supplement to ! 7: * Microsoft Development Tools and/or WinHelp documentation. ! 8: * See these sources for detailed information regarding the ! 9: * Microsoft samples programs. ! 10: \******************************************************************************/ ! 11: ! 12: /****************************** Module Header ******************************* ! 13: * Module Name: COMPLIST.C ! 14: * ! 15: * Supports a list of compitems, where each compitem represents ! 16: * a pair of matching files, or an unmatched file. ! 17: * ! 18: * Functions: ! 19: * ! 20: * complist_filedialog() ! 21: * complist_dirdialog() ! 22: * complist_args() ! 23: * complist_getitems() ! 24: * complist_delete() ! 25: * complist_savelist() ! 26: * complist_copyfiles() ! 27: * complist_dodlg_savelist() ! 28: * complist_dodlg_copyfiles() ! 29: * complist_match() ! 30: * complist_new() ! 31: * complist_dodlg_dir() ! 32: * ! 33: * Comments: ! 34: * ! 35: * We build lists of filenames from two pathnames (using the ! 36: * scandir module) and then traverse the two lists comparing names. ! 37: * Where the names match, we create a CompItem from the matching ! 38: * names. Where there is an unmatched name, we create a compitem for it. ! 39: * ! 40: * We may also be asked to create a complist for two individual files: ! 41: * here we create a single compitem for them as a matched pair even if ! 42: * the names don't match. ! 43: * ! 44: ****************************************************************************/ ! 45: ! 46: #include <windows.h> ! 47: #include <stdlib.h> ! 48: #include <string.h> ! 49: #include <dos.h> ! 50: #include <direct.h> ! 51: ! 52: #include "gutils.h" ! 53: #include "state.h" ! 54: #include "windiff.h" ! 55: #include "wdiffrc.h" ! 56: #include "list.h" ! 57: #include "line.h" ! 58: #include "scandir.h" ! 59: #include "file.h" ! 60: #include "section.h" ! 61: #include "compitem.h" ! 62: #include "complist.h" ! 63: #include "view.h" ! 64: ! 65: ! 66: extern BOOL bAbort; /* defined in windiff.c Read only here */ ! 67: ! 68: /* ! 69: * The COMPLIST handle is typedef-ed to be a pointer to one ! 70: * of these struct complist ! 71: */ ! 72: struct complist { ! 73: DIRLIST left; /* left list of files */ ! 74: DIRLIST right; /* right list of files */ ! 75: LIST items; /* list of COMPITEMs */ ! 76: }; ! 77: ! 78: /* ---- module-wide data -------------------------------------*/ ! 79: ! 80: /* data for communicating between the SaveList dlg and complist_savelist() */ ! 81: ! 82: char dlg_file[256]; /* filename to save to */ ! 83: ! 84: /* checkbox options */ ! 85: BOOL dlg_identical, dlg_differ, dlg_left, dlg_right; ! 86: ! 87: /* data for Directory and SaveList */ ! 88: char dialog_leftname[256]; ! 89: char dialog_rightname[256]; ! 90: ! 91: /* ! 92: * data used by dodlg_copyfiles ! 93: */ ! 94: UINT dlg_options; ! 95: char dlg_root[256]; ! 96: ! 97: /*------------------------timing for performance measurements-----------------*/ ! 98: ! 99: static DWORD TickCount; /* time operation started, then time taken*/ ! 100: ! 101: ! 102: int FAR PASCAL complist_dodlg_savelist(HWND hDlg, UINT message, ! 103: UINT wParam, long lParam); ! 104: int FAR PASCAL complist_dodlg_copyfiles(HWND hDlg, UINT message, ! 105: UINT wParam, long lParam); ! 106: BOOL complist_match(COMPLIST cl, VIEW view, BOOL fDeep, BOOL fExact); ! 107: COMPLIST complist_new(void); ! 108: int FAR PASCAL complist_dodlg_dir(HWND hDlg, unsigned message, ! 109: WORD wParam, LONG lParam); ! 110: ! 111: ! 112: ! 113: /*************************************************************************** ! 114: * Function: complist_filedialog ! 115: * ! 116: * Purpose: ! 117: * ! 118: * Builds a complist by putting up two dialogs to allow the user to ! 119: * select two files. This will build a Complist with one CompItem (even ! 120: * if the names don't match). ! 121: * ! 122: ***************************************************************************/ ! 123: COMPLIST ! 124: complist_filedialog(VIEW view) ! 125: { ! 126: COMPLIST cl; ! 127: OFSTRUCT os1, os2; ! 128: char fname[256], FileExt[256], FileOpenSpec[256]; ! 129: ! 130: /* ask for the filenames */ ! 131: lstrcpy(FileExt, ".c"); ! 132: lstrcpy(FileOpenSpec, "*.*"); ! 133: lstrcpy(fname,""); ! 134: ! 135: if (!complist_open("Select First File", FileExt, FileOpenSpec, ! 136: &os1, fname) ) ! 137: return(NULL); ! 138: ! 139: lstrcpy(FileExt, ".c"); ! 140: lstrcpy(FileOpenSpec, "*.*"); ! 141: lstrcpy(fname,""); ! 142: ! 143: if (!complist_open("Select Second File", FileExt, FileOpenSpec, ! 144: &os2, fname) ) ! 145: return(NULL); ! 146: ! 147: /* alloc a new structure */ ! 148: cl = complist_new(); ! 149: ! 150: cl->left = dir_buildlist(os1.szPathName, TRUE); ! 151: cl->right = dir_buildlist(os2.szPathName, TRUE); ! 152: ! 153: ! 154: /* register with the view (must be done after the list is non-null) */ ! 155: view_setcomplist(view, cl); ! 156: ! 157: complist_match(cl, view, FALSE, TRUE); ! 158: ! 159: return(cl); ! 160: }/* complist_filedialog */ ! 161: ! 162: /*************************************************************************** ! 163: * Function: complist_dirdialog ! 164: * ! 165: * Purpose: ! 166: * ! 167: * Builds a new complist by querying the user for two directory ! 168: * names and scanning those in parallel. ! 169: * ! 170: * Names that match in the same directory will be paired - unmatched ! 171: * names will go in a compitem on their own. ! 172: * ! 173: ***************************************************************************/ ! 174: COMPLIST ! 175: complist_dirdialog(VIEW view) ! 176: { ! 177: DLGPROC lpProc; ! 178: BOOL fOK; ! 179: ! 180: /* put up a dialog for the two pathnames */ ! 181: lpProc = (DLGPROC)MakeProcInstance((WNDPROC)complist_dodlg_dir, hInst); ! 182: windiff_UI(TRUE); ! 183: fOK = DialogBox(hInst, "Directory", hwndClient, lpProc); ! 184: windiff_UI(FALSE); ! 185: FreeProcInstance(lpProc); ! 186: ! 187: if (!fOK) { ! 188: return(NULL); ! 189: } ! 190: ! 191: return complist_args( dialog_leftname, dialog_rightname ! 192: , view, FALSE ); ! 193: } /* complist_dirdialog */ ! 194: ! 195: ! 196: /*************************************************************************** ! 197: * Function: complist_args ! 198: * ! 199: * Purpose: ! 200: * ! 201: * Given two pathname strings, scan the directories and traverse them ! 202: * in parallel comparing matching names. ! 203: * ! 204: ***************************************************************************/ ! 205: COMPLIST ! 206: complist_args(LPSTR p1, LPSTR p2, VIEW view, BOOL fDeep) ! 207: { ! 208: COMPLIST cl; ! 209: char msg[256]; ! 210: ! 211: ! 212: /* alloc a new complist */ ! 213: cl = complist_new(); ! 214: ! 215: cl->left = dir_buildlist(p1, TRUE); ! 216: /* check that we could find the paths, and report if not */ ! 217: if (cl->left == NULL) { ! 218: wsprintf((LPTSTR)msg, "Couldn't find %s", p1); ! 219: MessageBox(NULL, msg, "Error", MB_OK | MB_ICONSTOP); ! 220: return(NULL); ! 221: } ! 222: ! 223: cl->right = dir_buildlist(p2, TRUE); ! 224: if (cl->right == NULL) { ! 225: wsprintf((LPTSTR)msg, "Couldn't find %s", p2); ! 226: MessageBox(NULL, msg, "Error", MB_OK | MB_ICONSTOP); ! 227: return(NULL); ! 228: } ! 229: ! 230: /* register with the view (must be done after building lists) */ ! 231: view_setcomplist(view, cl); ! 232: ! 233: complist_match(cl, view, fDeep, TRUE); ! 234: ! 235: return(cl); ! 236: } /* complist_args */ ! 237: ! 238: /*************************************************************************** ! 239: * Function: complist_getitems ! 240: * ! 241: * Purpose: ! 242: * ! 243: * Gets the handle to the list of COMPITEMs. The list continues to be ! 244: * owned by the COMPLIST, so don't delete except by calling complist_delete. ! 245: * ! 246: ***************************************************************************/ ! 247: LIST ! 248: complist_getitems(COMPLIST cl) ! 249: { ! 250: if (cl == NULL) { ! 251: return(NULL); ! 252: } ! 253: ! 254: return(cl->items); ! 255: } ! 256: ! 257: /*************************************************************************** ! 258: * Function: complist_delete ! 259: * ! 260: * Purpose: ! 261: * ! 262: * Deletes a complist and all associated CompItems and DIRLISTs. Note this ! 263: * does not delete any VIEW - the VIEW owns the COMPLIST and not the other ! 264: * way around. ! 265: * ! 266: **************************************************************************/ ! 267: void ! 268: complist_delete(COMPLIST cl) ! 269: { ! 270: COMPITEM item; ! 271: ! 272: if (cl == NULL) { ! 273: return; ! 274: } ! 275: ! 276: /* delete the two directory scan lists */ ! 277: dir_delete(cl->left); ! 278: dir_delete(cl->right); ! 279: ! 280: /* delete the compitems in the list */ ! 281: List_TRAVERSE(cl->items, item) { ! 282: compitem_delete(item); ! 283: } ! 284: ! 285: /* delete the list itself */ ! 286: List_Destroy(&cl->items); ! 287: ! 288: gmem_free(hHeap, (LPSTR) cl, sizeof(struct complist)); ! 289: ! 290: } ! 291: ! 292: /*************************************************************************** ! 293: * Function: complist_savelist ! 294: * ! 295: * Purpose: ! 296: * ! 297: * Writes out to a text file the list of compitems as relative filenames ! 298: * one per line. ! 299: * ! 300: * If savename is non-null, use this as the filename for output; otherwise, ! 301: * query the user via a dialog for the filename and include options. ! 302: * ! 303: **************************************************************************/ ! 304: void ! 305: complist_savelist(COMPLIST cl, LPSTR savename, UINT options) ! 306: { ! 307: DLGPROC lpProc; ! 308: static BOOL done_init = FALSE; ! 309: BOOL bOK; ! 310: int fh, state; ! 311: OFSTRUCT os; ! 312: char msg[256]; ! 313: HCURSOR hcurs; ! 314: COMPITEM ci; ! 315: LPSTR pstr, lhead, rhead; ! 316: int nFiles = 0; ! 317: ! 318: if (!done_init) { ! 319: /* init the options once round - but keep the same options ! 320: * for the rest of the session. ! 321: */ ! 322: ! 323: /* first init default options */ ! 324: dlg_identical = FALSE; ! 325: dlg_differ = TRUE; ! 326: dlg_left = TRUE; ! 327: dlg_right = FALSE; ! 328: ! 329: dlg_file[0] = '\0'; ! 330: ! 331: done_init = TRUE; ! 332: } ! 333: ! 334: if (cl == NULL) { ! 335: return; ! 336: } ! 337: ! 338: if (savename == NULL) { ! 339: ! 340: /* store the left and right rootnames so that dodlg_savelist ! 341: * can display them in the dialog. ! 342: */ ! 343: pstr = dir_getroot_list(cl->left); ! 344: lstrcpy(dialog_leftname, pstr); ! 345: dir_freeroot_list(cl->left, pstr); ! 346: ! 347: pstr = dir_getroot_list(cl->right); ! 348: lstrcpy(dialog_rightname, pstr); ! 349: dir_freeroot_list(cl->right, pstr); ! 350: ! 351: lpProc = (DLGPROC)MakeProcInstance((WNDPROC)complist_dodlg_savelist, hInst); ! 352: windiff_UI(TRUE); ! 353: bOK = DialogBox(hInst, "SaveList", hwndClient, lpProc); ! 354: windiff_UI(FALSE); ! 355: FreeProcInstance(lpProc); ! 356: ! 357: if (!bOK) { ! 358: /* user cancelled from dialog box */ ! 359: return; ! 360: } ! 361: savename = dlg_file; ! 362: ! 363: } else { ! 364: dlg_identical = (options & INCLUDE_SAME); ! 365: dlg_differ = (options & INCLUDE_DIFFER); ! 366: dlg_left = (options & INCLUDE_LEFTONLY); ! 367: dlg_right = (options & INCLUDE_RIGHTONLY); ! 368: } ! 369: ! 370: ! 371: /* try to open the file */ ! 372: fh = OpenFile(savename, &os, OF_CREATE|OF_READWRITE|OF_SHARE_DENY_WRITE); ! 373: if (fh < 0) { ! 374: wsprintf((LPTSTR)msg, "Cannot open %s", savename); ! 375: windiff_UI(TRUE); ! 376: MessageBox(NULL, msg, "Windiff", MB_ICONSTOP|MB_OK); ! 377: windiff_UI(FALSE); ! 378: return; ! 379: } ! 380: ! 381: hcurs = SetCursor(LoadCursor(NULL, IDC_WAIT)); ! 382: ! 383: /* write out the header line */ ! 384: lhead = dir_getroot_list(cl->left); ! 385: rhead = dir_getroot_list(cl->right); ! 386: wsprintf((LPTSTR)msg, "-- %s : %s -- includes %s%s%s%s files\n", ! 387: lhead, rhead, ! 388: (LPSTR) (dlg_identical ? "identical," : ""), ! 389: (LPSTR) (dlg_left ? "left-only," : ""), ! 390: (LPSTR) (dlg_right ? "right-only," : ""), ! 391: (LPSTR) (dlg_differ ? "differing" : "") ); ! 392: _lwrite(fh, msg, lstrlen(msg)); ! 393: dir_freeroot_list(cl->left, lhead); ! 394: dir_freeroot_list(cl->right, rhead); ! 395: ! 396: ! 397: /* traverse the list of compitems looking for the ! 398: * ones we are supposed to include ! 399: */ ! 400: List_TRAVERSE(cl->items, ci) { ! 401: ! 402: /* check if files of this type are to be listed */ ! 403: state = compitem_getstate(ci); ! 404: ! 405: if ((state == STATE_SAME) && (!dlg_identical)) { ! 406: continue; ! 407: } else if ((state == STATE_DIFFER) && (!dlg_differ)) { ! 408: continue; ! 409: } else if ((state == STATE_FILELEFTONLY) && (!dlg_left)) { ! 410: continue; ! 411: } else if ((state == STATE_FILERIGHTONLY) && (!dlg_right)) { ! 412: continue; ! 413: } ! 414: ! 415: nFiles++; ! 416: ! 417: /* output the list line */ ! 418: wsprintf((LPTSTR)msg, "%s", compitem_gettext_tag(ci)); ! 419: _lwrite(fh, msg, lstrlen(msg)); ! 420: ! 421: wsprintf((LPTSTR)msg, "\n"); ! 422: _lwrite(fh, msg, strlen(msg)); ! 423: } ! 424: ! 425: /* write tail line */ ! 426: wsprintf((LPTSTR)msg, "-- %d files listed\n", nFiles); ! 427: _lwrite(fh, msg, lstrlen(msg)); ! 428: ! 429: /* - close file and we are finished */ ! 430: _lclose(fh); ! 431: ! 432: SetCursor(hcurs); ! 433: } /* complist_savelist */ ! 434: ! 435: /*************************************************************************** ! 436: * Function: complist_copyfiles ! 437: * ! 438: * Purpose: ! 439: * ! 440: * To copy files to a new directory newroot. if newroot is NULL, query the user ! 441: * via a dialog to get the new dir name and options. ! 442: * ! 443: * Options are either COPY_FROMLEFT or COPY_FROMRIGHT (indicating which ! 444: * tree is to be the source of the files, plus any or all of ! 445: * INCLUDE_SAME, INCLUDE_DIFFER and INCLUDE_LEFT (INCLUDE_LEFT ! 446: * and INCLUDE_RIGHT are treated the same here since the COPY_FROM* option ! 447: * indicates which side to copy from). ! 448: * ! 449: ***************************************************************************/ ! 450: void ! 451: complist_copyfiles(COMPLIST cl, LPSTR newroot, UINT options) ! 452: { ! 453: int nFiles = 0; ! 454: int nFails = 0; ! 455: static BOOL done_init = FALSE; ! 456: LPSTR pstr; ! 457: char buffer[64]; ! 458: DIRITEM diritem; ! 459: DLGPROC lpProc; ! 460: BOOL bOK; ! 461: COMPITEM ci; ! 462: int state; ! 463: ! 464: if (!done_init) { ! 465: /* ! 466: * one-time initialisation of dialog defaults ! 467: */ ! 468: dlg_options = COPY_FROMLEFT|INCLUDE_LEFTONLY|INCLUDE_DIFFER; ! 469: dlg_root[0] = '\0'; ! 470: done_init = TRUE; ! 471: } ! 472: ! 473: if (cl == NULL) { ! 474: return; ! 475: } ! 476: ! 477: ! 478: if (newroot == NULL) { ! 479: /* ! 480: * put up dialog to query rootname and options ! 481: */ ! 482: ! 483: /* store the left and right rootnames so that the dlg proc ! 484: * can display them in the dialog. ! 485: */ ! 486: pstr = dir_getroot_list(cl->left); ! 487: lstrcpy(dialog_leftname, pstr); ! 488: dir_freeroot_list(cl->left, pstr); ! 489: ! 490: pstr = dir_getroot_list(cl->right); ! 491: lstrcpy(dialog_rightname, pstr); ! 492: dir_freeroot_list(cl->right, pstr); ! 493: ! 494: do { ! 495: lpProc = (DLGPROC)MakeProcInstance((WNDPROC)complist_dodlg_copyfiles, hInst); ! 496: windiff_UI(TRUE); ! 497: bOK = DialogBox(hInst, "CopyFiles", hwndClient, lpProc); ! 498: windiff_UI(FALSE); ! 499: FreeProcInstance(lpProc); ! 500: ! 501: if (!bOK) { ! 502: /* user cancelled from dialog box */ ! 503: return; ! 504: } ! 505: if (lstrlen(dlg_root) == 0) { ! 506: windiff_UI(TRUE); ! 507: MessageBox(NULL, "Please enter the directory name", ! 508: "Windiff", MB_ICONSTOP|MB_OK); ! 509: windiff_UI(FALSE); ! 510: } ! 511: } while (lstrlen(dlg_root) == 0); ! 512: ! 513: } else { ! 514: dlg_options = options; ! 515: lstrcpy(dlg_root, newroot); ! 516: } ! 517: ! 518: TickCount = GetTickCount(); ! 519: ! 520: if (dlg_options & COPY_FROMLEFT) { ! 521: if (!dir_startcopy(cl->left)) ! 522: return; ! 523: } else { ! 524: if (!dir_startcopy(cl->right)) ! 525: return; ! 526: } ! 527: ! 528: /* ! 529: * traverse the list of compitems copying files as necessary ! 530: */ ! 531: List_TRAVERSE(cl->items, ci) { ! 532: ! 533: if (bAbort){ ! 534: break; /* fall into end_copy processing */ ! 535: } ! 536: /* check if files of this type are to be copied */ ! 537: state = compitem_getstate(ci); ! 538: ! 539: if ((state == STATE_SAME) && !(dlg_options & INCLUDE_SAME)) { ! 540: continue; ! 541: } else if ((state == STATE_DIFFER) && !(dlg_options & INCLUDE_DIFFER)) { ! 542: continue; ! 543: } else if (state == STATE_FILELEFTONLY) { ! 544: if (dlg_options & COPY_FROMRIGHT) { ! 545: continue; ! 546: } ! 547: if ((dlg_options & (INCLUDE_LEFTONLY | INCLUDE_RIGHTONLY)) == 0) { ! 548: continue; ! 549: } ! 550: } else if (state == STATE_FILERIGHTONLY) { ! 551: if (dlg_options & COPY_FROMLEFT) { ! 552: continue; ! 553: } ! 554: if ((dlg_options & (INCLUDE_LEFTONLY | INCLUDE_RIGHTONLY)) == 0) { ! 555: continue; ! 556: } ! 557: } ! 558: ! 559: if (dlg_options & COPY_FROMLEFT) { ! 560: diritem = file_getdiritem(compitem_getleftfile(ci)); ! 561: } else { ! 562: diritem = file_getdiritem(compitem_getrightfile(ci)); ! 563: } ! 564: ! 565: /* ! 566: * copy the file to the new root directory ! 567: */ ! 568: if (dir_copy(diritem, dlg_root) == FALSE) { ! 569: nFails++; ! 570: pstr = dir_getrelname(diritem); ! 571: wsprintf((LPTSTR)buffer, "failed to copy %s", pstr); ! 572: dir_freerelname(diritem, pstr); ! 573: ! 574: if (MessageBox(NULL, buffer, "Error", MB_OKCANCEL | MB_ICONSTOP) == IDCANCEL) ! 575: /* user pressed cancel - abort current operation*/ ! 576: /* fall through to end-copy processing */ ! 577: break; ! 578: ! 579: } else { ! 580: nFiles++; ! 581: } ! 582: ! 583: wsprintf((LPTSTR)buffer, "%4d files requested. Copying...", nFiles); ! 584: SetStatus(buffer); ! 585: ! 586: ! 587: /* ! 588: * allow user interface to continue ! 589: */ ! 590: if (Poll()) { ! 591: /* abort requested */ ! 592: TickCount = GetTickCount()-TickCount; ! 593: windiff_UI(TRUE); ! 594: MessageBox(hwndClient, "Copy Aborted", ! 595: "WinDiff", MB_OK|MB_ICONINFORMATION); ! 596: windiff_UI(FALSE); ! 597: break; ! 598: } ! 599: ! 600: } /* traverse */ ! 601: if (dlg_options & COPY_FROMLEFT) { ! 602: nFails = dir_endcopy(cl->left); ! 603: } else { ! 604: nFails = dir_endcopy(cl->right); ! 605: } ! 606: TickCount = GetTickCount()-TickCount; ! 607: ! 608: if (nFails<0) { ! 609: wsprintf((LPTSTR)buffer, "Copy Complete: %d files failed", -nFails); ! 610: } else { ! 611: wsprintf((LPTSTR)buffer, "Copy Complete %d files copied", nFails); ! 612: } ! 613: windiff_UI(TRUE); ! 614: MessageBox(hwndClient, buffer, "WinDiff", MB_OK|MB_ICONINFORMATION); ! 615: windiff_UI(FALSE); ! 616: ! 617: buffer[0] = '\0'; ! 618: SetStatus(buffer); ! 619: } /* complist_copyfiles */ ! 620: ! 621: ! 622: /*************************************************************************** ! 623: * Function: complist_match ! 624: * ! 625: * Purpose: ! 626: * ! 627: * Matches up two lists of filenames ! 628: * ! 629: * Commentsz: ! 630: * ! 631: * We can find out from the DIRLIST handle whether the original list ! 632: * was a file or a directory name. ! 633: * If the user typed: ! 634: * two file names - match these two item even if the names differ ! 635: * ! 636: * two dirs - match only those items whose names match ! 637: * ! 638: * one file and one dir ! 639: * - try to find a file of that name in the dir. ! 640: * ! 641: * This function returns TRUE if the complist_match was ok, or FALSE if it was ! 642: * aborted in some way. ! 643: * ! 644: ***************************************************************************/ ! 645: BOOL ! 646: complist_match(COMPLIST cl, VIEW view, BOOL fDeep, BOOL fExact) ! 647: { ! 648: LPSTR lname; ! 649: LPSTR rname; ! 650: DIRITEM leftitem, rightitem; ! 651: int cmpvalue; ! 652: ! 653: TickCount = GetTickCount(); ! 654: ! 655: if (dir_isfile(cl->left) ) { ! 656: ! 657: if (dir_isfile(cl->right)) { ! 658: /* two files */ ! 659: ! 660: /* there should be one item in each list - make ! 661: * a compitem by matching these two and append it to the ! 662: * list ! 663: */ ! 664: compitem_new(dir_firstitem(cl->left), ! 665: dir_firstitem(cl->right), cl->items, fExact); ! 666: ! 667: view_newitem(view); ! 668: ! 669: TickCount = GetTickCount() - TickCount; ! 670: return TRUE; ! 671: } ! 672: /* left is file, right is dir */ ! 673: leftitem = dir_firstitem(cl->left); ! 674: rightitem = dir_firstitem(cl->right); ! 675: lname = dir_getrelname(leftitem); ! 676: while (rightitem != NULL) { ! 677: rname = dir_getrelname(rightitem); ! 678: cmpvalue = lstrcmpi(lname, rname); ! 679: dir_freerelname(rightitem, rname); ! 680: ! 681: if (cmpvalue == 0) { ! 682: /* this is the match */ ! 683: compitem_new(leftitem, rightitem, cl->items, fExact); ! 684: view_newitem(view); ! 685: ! 686: dir_freerelname(leftitem, lname); ! 687: ! 688: TickCount = GetTickCount() - TickCount; ! 689: return(TRUE); ! 690: } ! 691: ! 692: rightitem = dir_nextitem(cl->right, rightitem, fDeep); ! 693: } ! 694: /* not found */ ! 695: dir_freerelname(leftitem, lname); ! 696: compitem_new(leftitem, NULL, cl->items, fExact); ! 697: view_newitem(view); ! 698: TickCount = GetTickCount() - TickCount; ! 699: return(TRUE); ! 700: ! 701: } else if (dir_isfile(cl->right)) { ! 702: ! 703: /* left is dir, right is file */ ! 704: ! 705: /* loop through the left dir, looking for ! 706: * a file that has the same name as rightitem ! 707: */ ! 708: ! 709: leftitem = dir_firstitem(cl->left); ! 710: rightitem = dir_firstitem(cl->right); ! 711: rname = dir_getrelname(rightitem); ! 712: while (leftitem != NULL) { ! 713: lname = dir_getrelname(leftitem); ! 714: cmpvalue = lstrcmpi(lname, rname); ! 715: dir_freerelname(leftitem, lname); ! 716: ! 717: if (cmpvalue == 0) { ! 718: /* this is the match */ ! 719: compitem_new(leftitem, rightitem, cl->items, fExact); ! 720: view_newitem(view); ! 721: ! 722: dir_freerelname(rightitem, rname); ! 723: ! 724: TickCount = GetTickCount() - TickCount; ! 725: return(TRUE); ! 726: } ! 727: ! 728: leftitem = dir_nextitem(cl->left, leftitem, fDeep); ! 729: } ! 730: /* not found */ ! 731: dir_freerelname(rightitem, rname); ! 732: compitem_new(NULL, rightitem, cl->items, fExact); ! 733: view_newitem(view); ! 734: TickCount = GetTickCount() - TickCount; ! 735: return(TRUE); ! 736: } ! 737: ! 738: /* two directories */ ! 739: ! 740: /* traverse the two lists in parallel comparing the relative names*/ ! 741: ! 742: leftitem = dir_firstitem(cl->left); ! 743: rightitem = dir_firstitem(cl->right); ! 744: while ((leftitem != NULL) && (rightitem != NULL)) { ! 745: ! 746: lname = dir_getrelname(leftitem); ! 747: rname = dir_getrelname(rightitem); ! 748: cmpvalue = utils_CompPath(lname, rname); ! 749: dir_freerelname(leftitem, lname); ! 750: dir_freerelname(rightitem, rname); ! 751: ! 752: if (cmpvalue == 0) { ! 753: compitem_new(leftitem, rightitem, cl->items, fExact); ! 754: if (view_newitem(view)) { ! 755: TickCount = GetTickCount() - TickCount; ! 756: return(FALSE); ! 757: } ! 758: leftitem = dir_nextitem(cl->left, leftitem, fDeep); ! 759: rightitem = dir_nextitem(cl->right, rightitem, fDeep); ! 760: ! 761: } else if (cmpvalue < 0) { ! 762: compitem_new(leftitem, NULL, cl->items, fExact); ! 763: if (view_newitem(view)) { ! 764: TickCount = GetTickCount() - TickCount; ! 765: return(FALSE); ! 766: } ! 767: leftitem = dir_nextitem(cl->left, leftitem, fDeep); ! 768: } else { ! 769: compitem_new(NULL, rightitem, cl->items, fExact); ! 770: if (view_newitem(view)) { ! 771: TickCount = GetTickCount() - TickCount; ! 772: return(FALSE); ! 773: } ! 774: rightitem = dir_nextitem(cl->right, rightitem, fDeep); ! 775: } ! 776: } ! 777: ! 778: ! 779: /* any left over are unmatched */ ! 780: while (leftitem != NULL) { ! 781: compitem_new(leftitem, NULL, cl->items, fExact); ! 782: if (view_newitem(view)) { ! 783: TickCount = GetTickCount() - TickCount; ! 784: return(FALSE); ! 785: } ! 786: leftitem = dir_nextitem(cl->left, leftitem, fDeep); ! 787: } ! 788: while (rightitem != NULL) { ! 789: compitem_new(NULL, rightitem, cl->items, fExact); ! 790: if (view_newitem(view)) { ! 791: TickCount = GetTickCount() - TickCount; ! 792: return(FALSE); ! 793: } ! 794: rightitem = dir_nextitem(cl->right, rightitem, fDeep); ! 795: } ! 796: TickCount = GetTickCount() - TickCount; ! 797: return(TRUE); ! 798: } /* complist_match */ ! 799: ! 800: /* return time last operation took in milliseconds */ ! 801: DWORD complist_querytime(void) ! 802: { return TickCount; ! 803: } ! 804: ! 805: ! 806: /*************************************************************************** ! 807: * Function: complist_dodlg_savelist ! 808: * ! 809: * Purpose: ! 810: * ! 811: * Dialog to query about filename and types of files. Init dlg fields from ! 812: * the dlg_* variables, and save state to the dlg_* variables on dialog ! 813: * close. return TRUE for OK, or FALSE for cancel (from the dialogbox() ! 814: * using EndDialog). ! 815: * ! 816: **************************************************************************/ ! 817: int FAR PASCAL ! 818: complist_dodlg_savelist(HWND hDlg, UINT message, UINT wParam, long lParam) ! 819: { ! 820: static char buffer[256]; ! 821: ! 822: switch(message) { ! 823: ! 824: ! 825: case WM_INITDIALOG: ! 826: SendDlgItemMessage(hDlg, IDD_IDENTICAL, BM_SETCHECK, ! 827: dlg_identical ? 1 : 0, 0); ! 828: SendDlgItemMessage(hDlg, IDD_DIFFER, BM_SETCHECK, ! 829: dlg_differ ? 1 : 0, 0); ! 830: SendDlgItemMessage(hDlg, IDD_LEFT, BM_SETCHECK, ! 831: dlg_left ? 1 : 0, 0); ! 832: SendDlgItemMessage(hDlg, IDD_RIGHT, BM_SETCHECK, ! 833: dlg_right ? 1 : 0, 0); ! 834: ! 835: SetDlgItemText(hDlg, IDD_FILE, dlg_file); ! 836: ! 837: /* convert 'left tree' into the right name */ ! 838: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_leftname); ! 839: SendDlgItemMessage(hDlg, IDD_LEFT, WM_SETTEXT, 0, (DWORD) (LPSTR) buffer); ! 840: ! 841: /* convert 'right tree' msg into correct path */ ! 842: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_rightname); ! 843: SendDlgItemMessage(hDlg, IDD_RIGHT, WM_SETTEXT, 0, (DWORD) (LPSTR) buffer); ! 844: ! 845: ! 846: return(TRUE); ! 847: ! 848: case WM_COMMAND: ! 849: switch (GET_WM_COMMAND_ID(wParam, lParam)) { ! 850: ! 851: case IDOK: ! 852: dlg_identical = (SendDlgItemMessage(hDlg, IDD_IDENTICAL, ! 853: BM_GETCHECK, 0, 0) == 1); ! 854: dlg_differ = (SendDlgItemMessage(hDlg, IDD_DIFFER, ! 855: BM_GETCHECK, 0, 0) == 1); ! 856: dlg_left = (SendDlgItemMessage(hDlg, IDD_LEFT, ! 857: BM_GETCHECK, 0, 0) == 1); ! 858: dlg_right = (SendDlgItemMessage(hDlg, IDD_RIGHT, ! 859: BM_GETCHECK, 0, 0) == 1); ! 860: GetDlgItemText(hDlg, IDD_FILE, dlg_file, sizeof(dlg_file)); ! 861: ! 862: EndDialog(hDlg, TRUE); ! 863: break; ! 864: ! 865: case IDCANCEL: ! 866: EndDialog(hDlg, FALSE); ! 867: break; ! 868: } ! 869: } ! 870: return(FALSE); ! 871: } /* complist_dodlg_savelist */ ! 872: ! 873: /*************************************************************************** ! 874: * Function: complist_dodlg_copyfiles ! 875: * ! 876: * Purpose: ! 877: * ! 878: * dialog to get directory name and inclusion options. Init dlg fields from ! 879: * the dlg_* variables, and save state to the dlg_* variables on dialog ! 880: * close. return TRUE for OK, or FALSE for cancel (from the dialogbox() ! 881: * using EndDialog). ! 882: * ! 883: **************************************************************************/ ! 884: int FAR PASCAL ! 885: complist_dodlg_copyfiles(HWND hDlg, UINT message, UINT wParam, long lParam) ! 886: { ! 887: static char buffer[256]; ! 888: ! 889: switch(message) { ! 890: ! 891: ! 892: case WM_INITDIALOG: ! 893: /* ! 894: * set checkboxes and directory field to defaults ! 895: */ ! 896: CheckDlgButton(hDlg, IDD_IDENTICAL, ! 897: (dlg_options & INCLUDE_SAME) ? 1 : 0); ! 898: ! 899: CheckDlgButton(hDlg, IDD_DIFFER, ! 900: (dlg_options & INCLUDE_DIFFER) ? 1 : 0); ! 901: ! 902: CheckDlgButton(hDlg, IDD_LEFT, ! 903: (dlg_options & (INCLUDE_LEFTONLY|INCLUDE_RIGHTONLY)) ? 1 : 0); ! 904: ! 905: SetDlgItemText(hDlg, IDD_DIR1, dlg_root); ! 906: ! 907: /* ! 908: * set 'copy from' buttons to have the full pathname ! 909: */ ! 910: SetDlgItemText(hDlg, IDD_FROMLEFT, dialog_leftname); ! 911: SetDlgItemText(hDlg, IDD_FROMRIGHT, dialog_rightname); ! 912: ! 913: /* ! 914: * set default radio button for copy from, and set ! 915: * the text on the 'files only in...' checkbox to ! 916: * indicate which path is being selected ! 917: */ ! 918: if (dlg_options & COPY_FROMLEFT) { ! 919: CheckRadioButton(hDlg, IDD_FROMLEFT, IDD_FROMRIGHT, ! 920: IDD_FROMLEFT); ! 921: ! 922: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_leftname); ! 923: SetDlgItemText(hDlg, IDD_LEFT, buffer); ! 924: } else { ! 925: CheckRadioButton(hDlg, IDD_FROMLEFT, IDD_FROMRIGHT, ! 926: IDD_FROMRIGHT); ! 927: ! 928: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_rightname); ! 929: SetDlgItemText(hDlg, IDD_LEFT, buffer); ! 930: } ! 931: ! 932: return(TRUE); ! 933: ! 934: case WM_COMMAND: ! 935: switch (GET_WM_COMMAND_ID(wParam, lParam)) { ! 936: ! 937: case IDD_FROMLEFT: ! 938: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_leftname); ! 939: SetDlgItemText(hDlg, IDD_LEFT, buffer); ! 940: ! 941: dlg_options &= ~(COPY_FROMRIGHT); ! 942: dlg_options |= COPY_FROMLEFT; ! 943: break; ! 944: ! 945: case IDD_FROMRIGHT: ! 946: wsprintf((LPTSTR)buffer, "Files only in %s", (LPSTR) dialog_rightname); ! 947: SetDlgItemText(hDlg, IDD_LEFT, buffer); ! 948: ! 949: dlg_options &= ~(COPY_FROMLEFT); ! 950: dlg_options |= COPY_FROMRIGHT; ! 951: break; ! 952: ! 953: case IDOK: ! 954: if (SendDlgItemMessage(hDlg, IDD_IDENTICAL, ! 955: BM_GETCHECK, 0, 0) == 1) { ! 956: dlg_options |= INCLUDE_SAME; ! 957: } else { ! 958: dlg_options &= ~INCLUDE_SAME; ! 959: } ! 960: if (SendDlgItemMessage(hDlg, IDD_DIFFER, ! 961: BM_GETCHECK, 0, 0) == 1) { ! 962: dlg_options |= INCLUDE_DIFFER; ! 963: } else { ! 964: dlg_options &= ~INCLUDE_DIFFER; ! 965: } ! 966: if (SendDlgItemMessage(hDlg, IDD_LEFT, ! 967: BM_GETCHECK, 0, 0) == 1) { ! 968: dlg_options |= INCLUDE_LEFTONLY; ! 969: } else { ! 970: dlg_options &= ~INCLUDE_LEFTONLY; ! 971: } ! 972: GetDlgItemText(hDlg, IDD_DIR1, dlg_root, sizeof(dlg_root)); ! 973: ! 974: EndDialog(hDlg, TRUE); ! 975: break; ! 976: ! 977: case IDCANCEL: ! 978: EndDialog(hDlg, FALSE); ! 979: break; ! 980: } ! 981: } ! 982: return(FALSE); ! 983: } /* complist_dodlg_copyfiles */ ! 984: ! 985: /*************************************************************************** ! 986: * Function: complist_new ! 987: * ! 988: * Purpose: ! 989: * ! 990: * Allocates a new complist and initialise it ! 991: * ! 992: **************************************************************************/ ! 993: COMPLIST ! 994: complist_new(void) ! 995: { ! 996: COMPLIST cl; ! 997: ! 998: cl = (COMPLIST) gmem_get(hHeap, sizeof(struct complist)); ! 999: cl->left = NULL; ! 1000: cl->right = NULL; ! 1001: cl->items = List_Create(); ! 1002: ! 1003: return(cl); ! 1004: } /* complist_new */ ! 1005: ! 1006: /*************************************************************************** ! 1007: * Function: complist_dodlg_dir ! 1008: * ! 1009: * Purpose: ! 1010: * ! 1011: * Dialog box function to ask for two directory names. ! 1012: * no listing of files etc - just two edit fields in which the ! 1013: * user can type a file or a directory name. ! 1014: * ! 1015: * Initialises the names from win.ini, and stores them to win.ini first. ! 1016: * ! 1017: **************************************************************************/ ! 1018: int FAR PASCAL ! 1019: complist_dodlg_dir(HWND hDlg, unsigned message, WORD wParam, LONG lParam) ! 1020: { ! 1021: static char path[256]; ! 1022: static char buffer[256]; ! 1023: ! 1024: switch (message) { ! 1025: ! 1026: case WM_INITDIALOG: ! 1027: ! 1028: /* fill the edit fields with the current ! 1029: * directory as a good starting point ! 1030: */ ! 1031: _getcwd(path, sizeof(path)); ! 1032: AnsiLowerBuff(path, strlen(path)); ! 1033: GetProfileString(APPNAME, "NameLeft", path, buffer, 256); ! 1034: SetDlgItemText(hDlg, IDD_DIR1, buffer); ! 1035: GetProfileString(APPNAME, "NameRight", path, buffer, 256); ! 1036: SetDlgItemText(hDlg, IDD_DIR2, buffer); ! 1037: return(TRUE); ! 1038: ! 1039: case WM_COMMAND: ! 1040: switch (LOWORD(wParam)) { ! 1041: case IDCANCEL: ! 1042: EndDialog(hDlg, FALSE); ! 1043: return(TRUE); ! 1044: ! 1045: case IDOK: ! 1046: /* fetch the text from the dialog, and remember ! 1047: * it in win.ini ! 1048: */ ! 1049: ! 1050: GetDlgItemText(hDlg, IDD_DIR1, ! 1051: dialog_leftname, sizeof(dialog_leftname)); ! 1052: WriteProfileString(APPNAME, "NameLeft", dialog_leftname); ! 1053: ! 1054: GetDlgItemText(hDlg, IDD_DIR2, ! 1055: dialog_rightname, sizeof(dialog_rightname)); ! 1056: ! 1057: EndDialog(hDlg, TRUE); ! 1058: return(TRUE); ! 1059: } ! 1060: break; ! 1061: } ! 1062: return(FALSE); ! 1063: } /* complist_dodlg_dir */ ! 1064: ! 1065: /*************************************************************************** ! 1066: * Function: complist_open ! 1067: * ! 1068: * Purpose: ! 1069: * ! 1070: * Puts up dialog asking the user to select an existing file to open. ! 1071: * ! 1072: * Parameters: ! 1073: * ! 1074: * prompt - message to user indicating purpose of file ! 1075: * (to be displayed somewhere in dialog box. ! 1076: * ! 1077: * ext - default file extension if user enters file without ! 1078: * extension. ! 1079: * ! 1080: * spec - default file spec (eg *.*) ! 1081: * ! 1082: * osp - OFSTRUCT representing file, if successfully open. ! 1083: * ! 1084: * fn - buffer where filename (just final element) is returned. ! 1085: * ! 1086: * Returns: ! 1087: * ! 1088: * TRUE - if file selected and exists (tested with OF_EXIST). ! 1089: * ! 1090: * FALSE - if dialog cancelled. If user selects a file that we cannot ! 1091: * open, we complain and restart the dialog. ! 1092: * ! 1093: * Comments: ! 1094: * ! 1095: * if TRUE is returned, the file will have been successfully opened, ! 1096: * for reading and then closed again. ! 1097: * ! 1098: **************************************************************************/ ! 1099: ! 1100: BOOL FAR PASCAL ! 1101: complist_open(LPSTR prompt, LPSTR ext, LPSTR spec, OFSTRUCT FAR *osp, LPSTR fn) ! 1102: { ! 1103: OPENFILENAME ofn; ! 1104: char achFilters[256]; ! 1105: char achPath[256]; ! 1106: LPSTR chp; ! 1107: int fh; ! 1108: ! 1109: /* build filter-pair buffer to contain one pair - the spec filter, ! 1110: * twice (one of the pair should be the filter, the second should be ! 1111: * the title of the filter - we don't have a title so we use the ! 1112: * filter both times. remember double null at end of list of strings. ! 1113: */ ! 1114: lstrcpy(achFilters, spec); // filter + null ! 1115: chp = &achFilters[lstrlen(achFilters)+1]; //2nd string just after null ! 1116: lstrcpy(chp, spec); // filter name (+null) ! 1117: chp[lstrlen(chp)+1] = '\0'; // double null at end of list ! 1118: /* ! 1119: * initialise arguments to dialog proc ! 1120: */ ! 1121: ofn.lStructSize = sizeof(OPENFILENAME); ! 1122: ofn.hwndOwner = NULL; ! 1123: ofn.hInstance = NULL; ! 1124: ofn.lpstrFilter = achFilters; ! 1125: ofn.lpstrCustomFilter = (LPSTR)NULL; ! 1126: ofn.nMaxCustFilter = 0L; ! 1127: ofn.nFilterIndex = 1L; // first filter pair in list ! 1128: achPath[0] = '\0'; ! 1129: ofn.lpstrFile = achPath; // we need to get the full path to open ! 1130: ofn.nMaxFile = sizeof(achPath); ! 1131: ofn.lpstrFileTitle = fn; // return final elem of name here ! 1132: ofn.nMaxFileTitle = sizeof(fn); ! 1133: ofn.lpstrInitialDir = NULL; ! 1134: ofn.lpstrTitle = prompt; // dialog title is good place for prompt text ! 1135: ofn.Flags = OFN_FILEMUSTEXIST | ! 1136: OFN_HIDEREADONLY | ! 1137: OFN_PATHMUSTEXIST; ! 1138: ofn.lpstrDefExt = ext; ! 1139: ofn.nFileOffset = 0; ! 1140: ofn.nFileExtension = 0; ! 1141: ofn.lCustData = 0; ! 1142: ! 1143: /* ! 1144: * loop until the user cancels, or selects a file that we can open ! 1145: */ ! 1146: do { ! 1147: if (!GetOpenFileName(&ofn)) { ! 1148: return(FALSE); ! 1149: } ! 1150: ! 1151: fh = OpenFile(achPath, osp, OF_READ); ! 1152: ! 1153: if (fh == HFILE_ERROR) { ! 1154: if (MessageBox(NULL, "File Could Not Be Opened", "File Open", ! 1155: MB_OKCANCEL|MB_ICONSTOP) == IDCANCEL) { ! 1156: return(FALSE); ! 1157: } ! 1158: } ! 1159: } while (fh == HFILE_ERROR); ! 1160: ! 1161: _lclose(fh); ! 1162: ! 1163: return(TRUE); ! 1164: } ! 1165: ! 1166: /*************************************************************************** ! 1167: * Function: complist_getroot_left ! 1168: * ! 1169: * Purpose: ! 1170: * ! 1171: * Gets the root names of the left tree used to build this complist. ! 1172: * ! 1173: **************************************************************************/ ! 1174: LPSTR ! 1175: complist_getroot_left(COMPLIST cl) ! 1176: { ! 1177: return( dir_getroot_list(cl->left)); ! 1178: } ! 1179: ! 1180: /*************************************************************************** ! 1181: * Function: complist_getroot_right ! 1182: * ! 1183: * Purpose: ! 1184: * ! 1185: * Gets the root names of the right tree used to build this complist. ! 1186: * ! 1187: **************************************************************************/ ! 1188: LPSTR ! 1189: complist_getroot_right(COMPLIST cl) ! 1190: { ! 1191: return( dir_getroot_list(cl->right)); ! 1192: } ! 1193: /*************************************************************************** ! 1194: * Function: complist_freeroot_* ! 1195: * ! 1196: * Purpose: ! 1197: * ! 1198: * Frees up memory allocated in a call to complist_getroot*() ! 1199: * ! 1200: **************************************************************************/ ! 1201: void ! 1202: complist_freeroot_left(COMPLIST cl, LPSTR path) ! 1203: { ! 1204: dir_freeroot_list(cl->left, path); ! 1205: } ! 1206: ! 1207: void ! 1208: complist_freeroot_right(COMPLIST cl, LPSTR path) ! 1209: { ! 1210: dir_freeroot_list(cl->right, path); ! 1211: } ! 1212: ! 1213:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.