![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to view.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 view.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: VIEW.C ! 14: * ! 15: * Maps rows in window to items in COMPLIST ! 16: * ! 17: * Functions: ! 18: * ! 19: * view_new() ! 20: * view_setcomplist() ! 21: * view_getcomplist() ! 22: * view_close() ! 23: * view_delete() ! 24: * view_outline() ! 25: * view_expand() ! 26: * view_gettext() ! 27: * view_getlinenr_left() ! 28: * view_getlinenr_right() ! 29: * view_getwidth() ! 30: * view_getrowcount() ! 31: * view_getstate() ! 32: * view_getitem() ! 33: * view_isexpanded() ! 34: * view_getcurrenttag() ! 35: * view_newitem() ! 36: * view_changeviewoptions() ! 37: * view_changediffoptions() ! 38: * view_findchange() ! 39: * view_outline_opt() ! 40: * view_freemappings() ! 41: * view_findrow() ! 42: * view_expand_item() ! 43: * ! 44: * Comments: ! 45: * ! 46: * A view owns a COMPLIST, and talks to a table window. The table window ! 47: * shows 3 columns: line nr, tag and text. We also need to supply a state ! 48: * for each row (used to select colour scheme). ! 49: * ! 50: * The COMPLIST can give us a list of its COMPITEMs. Each of these can give ! 51: * us a tag (eg the filenames compared) and the text (usually the compare ! 52: * result), and the state. We make the line number from the ! 53: * COMPITEM's place in the list. ! 54: * ! 55: * If we are asked to switch to 'expand' mode, we ask the selected COMPITEM ! 56: * for its composite section list. We can then get the state (and thus ! 57: * the tag) from each SECTION, and the line nr and text from the LINEs within ! 58: * each section. ! 59: * ! 60: * When moving between expand and outline, and when refreshing the view ! 61: * for some option change, we have to be careful to keep the current row ! 62: * and the selected row in the table what the user would expect. ! 63: * ! 64: * Functions in this module can be called from the UI thread (to refresh ! 65: * the display) and simultaneously from a worker thread to update the ! 66: * view mapping (view_setcomplist, view_newitem). We use a critical section ! 67: * to manage the synchronisation. We need to protect all access/modification ! 68: * to the view structure elements (particularly bExpand, rows, pLines and ! 69: * pItems), BUT we must not hold the critical section over any calls ! 70: * to SendMessage. ! 71: * ! 72: * We use the global options in windiff.h, and we allocate memory from the ! 73: * heap hHeap which has been initialised elsewhere. Points in time-intensive ! 74: * loops call Poll() defined elsewhere. ! 75: * ! 76: ****************************************************************************/ ! 77: ! 78: #include <windows.h> ! 79: #include <stdlib.h> ! 80: #include <commdlg.h> ! 81: ! 82: #include "gutils.h" ! 83: #include "table.h" ! 84: #include "state.h" ! 85: #include "windiff.h" ! 86: #include "wdiffrc.h" ! 87: #include "list.h" ! 88: #include "line.h" ! 89: #include "scandir.h" ! 90: #include "file.h" ! 91: #include "section.h" ! 92: #include "compitem.h" ! 93: #include "complist.h" ! 94: #include "view.h" ! 95: ! 96: /* ! 97: * data structures ! 98: */ ! 99: ! 100: /* in expand mode, we keep an array of one of these per screen line. */ ! 101: typedef struct viewline { ! 102: LINE line; /* handle to LINE for this row */ ! 103: SECTION section; /* handle to section containing this line */ ! 104: int nr_left; /* line nr in left file */ ! 105: int nr_right; /* line nr in right file */ ! 106: } VIEWLINE, FAR * PVIEWLINE; ! 107: ! 108: ! 109: /* ! 110: * The users VIEW handle is in fact a pointer to this structure ! 111: */ ! 112: struct view { ! 113: ! 114: HWND hwnd; /* the table window to send notifies to */ ! 115: ! 116: COMPLIST cl; /* the complist that we own */ ! 117: ! 118: BOOL bExpand; /* true if we are in expand mode */ ! 119: ! 120: COMPITEM ciSelect; /* selected compitem (in expand mode) */ ! 121: ! 122: int rows; /* number of rows in this view */ ! 123: ! 124: char nrtext[12]; /* we use this in view_gettext for the line ! 125: * number column. overwritten on each call ! 126: */ ! 127: int maxtag, maxrest;/* column widths in characters for cols 1, 2 */ ! 128: ! 129: /* if we are in outline mode, we map the row number to one entry ! 130: * in this array of COMPITEM handles. this pointer will ! 131: * be NULL in expand mode ! 132: */ ! 133: COMPITEM FAR * pItems; ! 134: ! 135: /* in expand mode we use this array of line and section handles */ ! 136: PVIEWLINE pLines; ! 137: }; ! 138: ! 139: ! 140: CRITICAL_SECTION CSView; ! 141: static BOOL bDoneInit = FALSE; ! 142: ! 143: #define ViewEnter() EnterCriticalSection(&CSView); ! 144: #define ViewLeave() LeaveCriticalSection(&CSView); ! 145: ! 146: void view_outline_opt(VIEW view, BOOL bRedraw); ! 147: void view_freemappings(VIEW view); ! 148: int view_findrow(VIEW view, int number, BOOL bRight); ! 149: BOOL view_expand_item(VIEW view, COMPITEM ci); ! 150: ! 151: ! 152: /*************************************************************************** ! 153: * Function: view_new ! 154: * ! 155: * Purpose: ! 156: * ! 157: * Create a new view. At this point, we are told the table window handle, ! 158: * and nothing else. ! 159: * ! 160: */ ! 161: VIEW ! 162: view_new(HWND hwndTable) ! 163: { ! 164: VIEW view; ! 165: ! 166: if (!bDoneInit) { ! 167: InitializeCriticalSection(&CSView); ! 168: bDoneInit = TRUE; ! 169: } ! 170: ! 171: /* alloc the view from the heap */ ! 172: view = (VIEW) gmem_get(hHeap, sizeof(struct view)); ! 173: ! 174: /* set the default fields */ ! 175: view->hwnd = hwndTable; ! 176: view->cl = NULL; ! 177: view->bExpand = FALSE; ! 178: view->ciSelect = NULL; ! 179: view->rows = 0; ! 180: view->pItems = NULL; ! 181: view->pLines = NULL; ! 182: ! 183: return(view); ! 184: } ! 185: ! 186: ! 187: /*************************************************************************** ! 188: * Function: view_setcomplist ! 189: * ! 190: * Purpose: ! 191: * ! 192: * We have to separate view_new and view_setcomplist because we need ! 193: * to give the view handle to the complist and the complist handle to the ! 194: * view. So do a view_new to create a null view; then complist_new() to ! 195: * which you pass a view handle. The complist will then register itself ! 196: * with the view by calling this function. During the build of the complist, ! 197: * it will also update us by calling view_additem, so that we can refresh ! 198: * the display. ! 199: * ! 200: * Here we should initialise an outline view of the complist. ! 201: * ! 202: * We also talk to the status bar using SetNames to set the names of ! 203: * the two items. ! 204: */ ! 205: BOOL ! 206: view_setcomplist(VIEW view, COMPLIST cl) ! 207: { ! 208: LPSTR left, right, both; ! 209: ! 210: if (view == NULL) { ! 211: return(FALSE); ! 212: } ! 213: ! 214: /* there can be only one call to this per VIEW */ ! 215: if (view->cl != NULL) { ! 216: return (FALSE); ! 217: } ! 218: ! 219: ViewEnter(); ! 220: ! 221: view->cl = cl; ! 222: ! 223: /* set names on status bar to root names of left and right trees */ ! 224: left = complist_getroot_left(cl); ! 225: right = complist_getroot_right(cl); ! 226: both = gmem_get(hHeap, lstrlen(left) + lstrlen(right) +4); ! 227: wsprintf((LPTSTR)both, "%s : %s", left, right); ! 228: ViewLeave(); ! 229: SetNames(both); ! 230: ViewEnter(); ! 231: gmem_free(hHeap, both, lstrlen(both)+1); ! 232: complist_freeroot_left(cl, left); ! 233: complist_freeroot_right(cl, right); ! 234: ! 235: ViewLeave(); ! 236: ! 237: view_outline(view); ! 238: } ! 239: ! 240: ! 241: /*************************************************************************** ! 242: * Function: view_getcomplist ! 243: * ! 244: * Purpose: ! 245: * ! 246: * Return a handle to the complist owned by this view ! 247: */ ! 248: COMPLIST ! 249: view_getcomplist(VIEW view) ! 250: { ! 251: if (view == NULL) { ! 252: return(NULL); ! 253: } ! 254: ! 255: return(view->cl); ! 256: } ! 257: ! 258: ! 259: /*************************************************************************** ! 260: * Function: view_close ! 261: * ! 262: * Purpose: ! 263: * ! 264: * Close a view. Notify the table window that this view should be ! 265: * closed. When the table window has finished with it, it will send ! 266: * a TQ_CLOSE notify that should result in view_delete being called ! 267: * and the memory being freed. ! 268: */ ! 269: void ! 270: view_close(VIEW view) ! 271: { ! 272: if (view == NULL) { ! 273: return; ! 274: } ! 275: ! 276: SendMessage(view->hwnd, TM_NEWID, 0, 0); ! 277: } ! 278: ! 279: ! 280: /*************************************************************************** ! 281: * Function: view_delete ! 282: * ! 283: * Purpose: ! 284: * ! 285: * Delete a view and all associated data. ! 286: * ! 287: * This function should only be called in response to the table window ! 288: * sending a TQ_CLOSE message. To close the view, call view_close and ! 289: * wait for the TQ_CLOSE before calling this. ! 290: * ! 291: * We delete the associated COMPLIST and all its associated structures. ! 292: */ ! 293: void ! 294: view_delete(VIEW view) ! 295: { ! 296: if (view == NULL) { ! 297: return; ! 298: } ! 299: ! 300: /* we have two arrays that are used for the mapping - an array ! 301: * of compitem handles in outline mode, and an array of ! 302: * VIEWLINE structures in expand mode ! 303: */ ! 304: ! 305: view_freemappings(view); ! 306: ! 307: complist_delete(view->cl); ! 308: ! 309: gmem_free(hHeap, (LPSTR) view, sizeof(struct view)); ! 310: } ! 311: ! 312: ! 313: /*************************************************************************** ! 314: * Function: view_outline ! 315: * ! 316: * Purpose: ! 317: * ! 318: * Build an outline mode mapping where one row represents one COMPITEM in ! 319: * the list. Check the global option flag outline_include to see which items ! 320: * we should include. ! 321: * ! 322: * If we were in expand mode, then set as the selection the row in outline mode ! 323: * that we were expanding. Also remember to free up the expand mode mapping ! 324: * array ! 325: * ! 326: * Once we have built the new mapping, notify the table window to ! 327: * redraw itself. ! 328: */ ! 329: void ! 330: view_outline(VIEW view) ! 331: { ! 332: if (view == NULL) { ! 333: return; ! 334: } ! 335: ! 336: /* all work done by view_outline_opt - this function ! 337: * gives us the option of not updating the display ! 338: */ ! 339: view_outline_opt(view, TRUE); ! 340: } ! 341: ! 342: ! 343: ! 344: /*************************************************************************** ! 345: * Function: view_expand ! 346: * ! 347: * Purpose: ! 348: * ! 349: * Switch to expand mode, expanding the given row into a view ! 350: * of the differences in that file. ! 351: * ! 352: * Map the given row nr into a compitem handle, and then ! 353: * call the internal function with that. ! 354: */ ! 355: BOOL ! 356: view_expand(VIEW view, long row) ! 357: { ! 358: COMPITEM ci; ! 359: BOOL bRet; ! 360: ! 361: ViewEnter(); ! 362: ! 363: if ((view == NULL) || (view->bExpand)) { ! 364: /* no view, or already expanded */ ! 365: ViewLeave(); ! 366: return(FALSE); ! 367: } ! 368: ! 369: if (row >= view->rows) { ! 370: /* no such row */ ! 371: ViewLeave(); ! 372: return FALSE; ! 373: } ! 374: ! 375: /* remember the compitem we are expanding */ ! 376: ci = view->pItems[row]; ! 377: ! 378: bRet = view_expand_item(view, ci); ! 379: // view_expand_item does the... ! 380: // ViewLeave(); ! 381: return(bRet); ! 382: } ! 383: ! 384: ! 385: /*************************************************************************** ! 386: * Function: view_gettext ! 387: * ! 388: * Purpose: ! 389: * ! 390: * Return the text associated with a given column of a given row. ! 391: * Return a pointer that does not need to be freed after use - ie ! 392: * a pointer into our data somewhere, not a copy ! 393: */ ! 394: LPSTR ! 395: view_gettext(VIEW view, long row, int col) ! 396: { ! 397: int line; ! 398: int state; ! 399: LPSTR pstr; ! 400: ! 401: ! 402: if (view == NULL) { ! 403: return (NULL); ! 404: } ! 405: ! 406: ViewEnter(); ! 407: ! 408: if (row >= view->rows) { ! 409: ViewLeave(); ! 410: return(NULL); ! 411: } ! 412: ! 413: if (view->bExpand) { ! 414: /* we are in expand mode */ ! 415: ! 416: state = section_getstate(view->pLines[row].section); ! 417: ! 418: switch(col) { ! 419: case 0: ! 420: /* row nr */ ! 421: ! 422: /* line numbers can be from either original file ! 423: * this is a menu-selectable option ! 424: */ ! 425: switch(line_numbers) { ! 426: case IDM_NONRS: ! 427: pstr = NULL; ! 428: break; ! 429: ! 430: case IDM_LNRS: ! 431: line = view->pLines[row].nr_left; ! 432: if (state == STATE_MOVEDRIGHT) { ! 433: line = -line; ! 434: } ! 435: break; ! 436: ! 437: case IDM_RNRS: ! 438: line = view->pLines[row].nr_right; ! 439: if (state == STATE_MOVEDLEFT) { ! 440: line = -line; ! 441: } ! 442: break; ! 443: } ! 444: if (line == 0) { ! 445: ViewLeave(); ! 446: return(NULL); ! 447: } ! 448: ! 449: if (line < 0) { ! 450: /* lines that are moved appear twice. ! 451: * show the correct-sequence line nr ! 452: * for the out-of-seq. copy in brackets. ! 453: */ ! 454: wsprintf((LPTSTR)view->nrtext, "(%d)", abs(line)); ! 455: } else { ! 456: wsprintf((LPTSTR)view->nrtext, "%d", line); ! 457: } ! 458: pstr = view->nrtext; ! 459: break; ! 460: ! 461: case 1: ! 462: /* tag text - represents the state of the line */ ! 463: ! 464: ! 465: switch(state) { ! 466: case STATE_SAME: ! 467: pstr = " "; ! 468: break; ! 469: ! 470: case STATE_LEFTONLY: ! 471: pstr = " <! "; ! 472: break; ! 473: ! 474: case STATE_RIGHTONLY: ! 475: pstr = " !> "; ! 476: break; ! 477: ! 478: case STATE_MOVEDLEFT: ! 479: pstr = " <- "; ! 480: break; ! 481: ! 482: case STATE_MOVEDRIGHT: ! 483: pstr = " -> "; ! 484: break; ! 485: } ! 486: break; ! 487: ! 488: case 2: ! 489: /* main text - line */ ! 490: pstr = line_gettext(view->pLines[row].line); ! 491: break; ! 492: } ! 493: } else { ! 494: /* outline mode */ ! 495: switch(col) { ! 496: case 0: ! 497: /* row number - just the line number */ ! 498: wsprintf((LPTSTR)view->nrtext, "%d", row+1); ! 499: pstr = view->nrtext; ! 500: break; ! 501: ! 502: case 1: ! 503: /* tag */ ! 504: pstr = compitem_gettext_tag(view->pItems[row]); ! 505: break; ! 506: ! 507: case 2: ! 508: /* result text */ ! 509: pstr = compitem_gettext_result(view->pItems[row]); ! 510: break; ! 511: } ! 512: } ! 513: ViewLeave(); ! 514: return(pstr); ! 515: } ! 516: ! 517: /*************************************************************************** ! 518: * Function: view_getlinenr_left ! 519: * ! 520: * Purpose: ! 521: * ! 522: * Return the line number that this row had in the original left ! 523: * file. 0 if not in expand mode. 0 if this row was not in the left file. ! 524: * -(linenr) if this row is a MOVED line, and this is the right file ! 525: * copy ! 526: */ ! 527: int ! 528: view_getlinenr_left(VIEW view, long row) ! 529: { ! 530: int state, line; ! 531: ! 532: if ((view == NULL) || (row >= view->rows) || !view->bExpand) { ! 533: return 0; ! 534: } ! 535: ! 536: ViewEnter(); ! 537: state = section_getstate(view->pLines[row].section); ! 538: line = view->pLines[row].nr_left; ! 539: if (state == STATE_MOVEDRIGHT) { ! 540: line = -line; ! 541: } ! 542: ViewLeave(); ! 543: ! 544: return(line); ! 545: } ! 546: ! 547: /*************************************************************************** ! 548: * Function: view_getlinenr_right ! 549: * ! 550: * Purpose: ! 551: * ! 552: * Return the line number that this row had in the original right ! 553: * file. 0 if not in expand mode. 0 if this row was not in the right file. ! 554: * -(linenr) if this row is a MOVED line, and this is the left file ! 555: * copy ! 556: */ ! 557: int ! 558: view_getlinenr_right(VIEW view, long row) ! 559: { ! 560: int state, line; ! 561: ! 562: if ((view == NULL) || (row > view->rows) || !view->bExpand) { ! 563: return 0; ! 564: } ! 565: ! 566: ViewEnter(); ! 567: ! 568: state = section_getstate(view->pLines[row].section); ! 569: line = view->pLines[row].nr_right; ! 570: if (state == STATE_MOVEDLEFT) { ! 571: line = -line; ! 572: } ! 573: ViewLeave(); ! 574: ! 575: return(line); ! 576: } ! 577: ! 578: ! 579: /*************************************************************************** ! 580: * Function: view_getwidth ! 581: * ! 582: * Purpose: ! 583: * ! 584: * Find the maximum width in characters for the given column ! 585: */ ! 586: int ! 587: view_getwidth(VIEW view, int col) ! 588: { ! 589: if (view == NULL) { ! 590: return(0); ! 591: } ! 592: ! 593: switch(col) { ! 594: case 0: ! 595: /* line nr column - always 5 characters wide */ ! 596: return(5); ! 597: ! 598: case 1: ! 599: /* this is a proportional font field, so add on a margin ! 600: * for error ! 601: */ ! 602: return(view->maxtag + (view->maxtag / 20)); ! 603: case 2: ! 604: /* this now includes the tab expansion allowance */ ! 605: return(view->maxrest); ! 606: default: ! 607: return(0); ! 608: } ! 609: } ! 610: ! 611: /*************************************************************************** ! 612: * Function: view_getrowcount ! 613: * ! 614: * Purpose: ! 615: * ! 616: * How many rows are there in this view ? ! 617: */ ! 618: long ! 619: view_getrowcount(VIEW view) ! 620: { ! 621: if (view == NULL) { ! 622: return(0); ! 623: } ! 624: ! 625: return(view->rows); ! 626: } ! 627: ! 628: /*************************************************************************** ! 629: * Function: view_getstate ! 630: * ! 631: * Purpose: ! 632: * ! 633: * Return the state for the current row. This is used ! 634: * to select the text colour for the row ! 635: * ! 636: * States for sections are obtained from section_getstate (and apply, and ! 637: * to all lines in that section. States for compitems are obtained ! 638: * from compitem_getstate. ! 639: */ ! 640: int ! 641: view_getstate(VIEW view, long row) ! 642: { ! 643: int state; ! 644: ! 645: if (view == NULL) { ! 646: return(0); ! 647: } ! 648: ! 649: ViewEnter(); ! 650: if (row >= view->rows) { ! 651: state = 0; ! 652: } else if (view->bExpand) { ! 653: /* its a line state that's needed */ ! 654: state = section_getstate(view->pLines[row].section); ! 655: } else { ! 656: ! 657: /* its a compitem state */ ! 658: state = compitem_getstate(view->pItems[row]); ! 659: } ! 660: ViewLeave(); ! 661: return(state); ! 662: } ! 663: ! 664: /*************************************************************************** ! 665: * Function: view_gethandle ! 666: * ! 667: * Purpose: ! 668: * ! 669: * Return a handle to the current compitem. In expand mode, ! 670: * returns the handle to the compitem we are expanding. In outline ! 671: * mode, returns the handle to the compitem for the given row, if valid, ! 672: * or NULL otherwise. row is only used if not in expand mode. ! 673: */ ! 674: COMPITEM ! 675: view_getitem(VIEW view, long row) ! 676: { ! 677: COMPITEM ci; ! 678: ! 679: if (view == NULL) { ! 680: return(NULL); ! 681: } ! 682: ! 683: ViewEnter(); ! 684: ! 685: if (!view->bExpand) { ! 686: if ((row >= 0) && (row < view->rows)) { ! 687: ci = view->pItems[row]; ! 688: } else { ! 689: ci = NULL; ! 690: } ! 691: } else { ! 692: ci = view->ciSelect; ! 693: } ! 694: ! 695: ViewLeave(); ! 696: return(ci); ! 697: } ! 698: ! 699: /*************************************************************************** ! 700: * Function: view_isexpanded ! 701: * ! 702: * Purpose: ! 703: * ! 704: * Return TRUE if the current mapping is expanded mode ! 705: */ ! 706: BOOL ! 707: view_isexpanded(VIEW view) ! 708: { ! 709: if (view == NULL) { ! 710: return(FALSE); ! 711: } ! 712: return(view->bExpand); ! 713: } ! 714: ! 715: ! 716: /*************************************************************************** ! 717: * Function: view_getcurrenttag ! 718: * ! 719: * Purpose: ! 720: * ! 721: * Return a text string describing the view. This is NULL in outline mode, ! 722: * or the tag text for the current compitem in expanded mode ! 723: */ ! 724: LPSTR ! 725: view_getcurrenttag(VIEW view) ! 726: { ! 727: LPSTR str; ! 728: ! 729: if ((view == NULL) || (!view->bExpand)) { ! 730: return(NULL); ! 731: } else { ! 732: ViewEnter(); ! 733: ! 734: str = compitem_gettext_tag(view->ciSelect); ! 735: ! 736: ViewLeave(); ! 737: return(str); ! 738: ! 739: } ! 740: } ! 741: ! 742: ! 743: /*************************************************************************** ! 744: * Function: view_newitem ! 745: * ! 746: * Purpose: ! 747: * ! 748: * Notify that CompItems have been added to the complist. ! 749: * ! 750: * Rebuild the view (if in outline mode), and refresh the table. Use ! 751: * the table message TM_APPEND if possible (if column widths have not ! 752: * change). If we have to do TM_NEWLAYOUT, then ensure we scroll ! 753: * back to the right row afterwards. ! 754: * ! 755: * This causes a Poll() to take place. We return TRUE if an abort is ! 756: * pending - in this case, the caller should abandon the scan loop. ! 757: * ! 758: * Enter the critical section for this function since this can be ! 759: * called from the worker thread while the UI thread is using the ! 760: * view that we are about to change. ! 761: * ! 762: * EXCEPT THAT WE DON'T DARE. We cannot ever call SendMessage from the ! 763: * worker thread within CSView. If there is conflict, it will hang. ! 764: */ ! 765: BOOL ! 766: view_newitem(VIEW view) ! 767: { ! 768: int maxtag, maxrest; ! 769: long rownr; ! 770: ! 771: if ((view == NULL) || (view->bExpand)) { ! 772: /* not in outline mode - nothing to do */ ! 773: return(Poll()); ! 774: } ! 775: ! 776: /* save some state about the present mapping */ ! 777: maxtag = view->maxtag; ! 778: maxrest = view->maxrest; ! 779: ! 780: /* re-do the outline mapping, but don't tell the table ! 781: * class. ! 782: */ ! 783: view_outline_opt(view, FALSE); ! 784: ! 785: /* have the column widths changed ? */ ! 786: if ((maxtag < view->maxtag) || (maxrest < view->maxrest)) { ! 787: /* yes - need complete redraw */ ! 788: ! 789: /* find the row at the top of the window */ ! 790: rownr = SendMessage(view->hwnd, TM_TOPROW, FALSE, 0); ! 791: ! 792: /* switch to new mapping */ ! 793: SendMessage(view->hwnd, TM_NEWLAYOUT, 0, (DWORD) view); ! 794: ! 795: /* return to old row if possible - we know ! 796: * that row is still there since we have only added ! 797: * rows, and not changed any of the existing mapping ! 798: * ! 799: * Alas this is no longer true. However the table class ! 800: * will defend itself against calls for a bogus top row. ! 801: */ ! 802: if (rownr >= 0) { ! 803: SendMessage(view->hwnd, TM_TOPROW, TRUE, rownr); ! 804: } ! 805: } else { ! 806: /* no - we can just append */ ! 807: ! 808: /* ! 809: * The mapping may have ! 810: * changed since we released the critsec. however we are still ! 811: * safe. The table will not allow us to reduce the number of ! 812: * rows, so the worst that can happen is that the table will ! 813: * think there are too many rows, and the table message handler ! 814: * will handle this correctly (return null for the text). ! 815: * The only visible effect is therefore that the scrollbar ! 816: * position is wrong. ! 817: */ ! 818: ! 819: SendMessage(view->hwnd, TM_APPEND, view->rows, (DWORD) view); ! 820: } ! 821: ! 822: ! 823: /* Poll to keep the UI updated on NT. Returns true if abort pending. ! 824: */ ! 825: return(Poll()); ! 826: } ! 827: ! 828: /*************************************************************************** ! 829: * Function: view_changeviewoptions ! 830: * ! 831: * Purpose: ! 832: * ! 833: * The view mapping options (eg outline_include, expand_mode) have changed - ! 834: * re-do the mapping and then scroll back to the same position in the window ! 835: * if possible. ! 836: */ ! 837: void ! 838: view_changeviewoptions(VIEW view) ! 839: { ! 840: long row; ! 841: int state, number; ! 842: BOOL bRight; ! 843: ! 844: if (view == NULL) { ! 845: return; ! 846: } ! 847: ! 848: /* find what row we are currently on. Do this BEFORE we enter CSView */ ! 849: row = SendMessage(view->hwnd, TM_TOPROW, FALSE, 0); ! 850: ! 851: ViewEnter(); ! 852: ! 853: if (!view->bExpand) { ! 854: ! 855: /* outline mode. maintaining current position is ! 856: * unimportant ! 857: */ ! 858: view_outline(view); ! 859: ViewLeave(); ! 860: return; ! 861: } ! 862: ! 863: /* expanded mode */ ! 864: ! 865: ! 866: /* save the line number on one side (and remember which side) */ ! 867: if (row >= view->rows) { ! 868: number = -1; ! 869: } else { ! 870: state = section_getstate(view->pLines[row].section); ! 871: if ((state == STATE_MOVEDRIGHT) || ! 872: (state == STATE_RIGHTONLY)) { ! 873: bRight = TRUE; ! 874: number = view->pLines[row].nr_right; ! 875: } else { ! 876: bRight = FALSE; ! 877: number = view->pLines[row].nr_left; ! 878: } ! 879: } ! 880: ! 881: /* make the new mapping */ ! 882: view_expand_item(view, view->ciSelect); ! 883: ! 884: /* find the nearest row in the new view */ ! 885: if (number >= 0) { ! 886: ! 887: ViewEnter(); ! 888: row = view_findrow(view, number, bRight); ! 889: ViewLeave(); ! 890: ! 891: /* scroll this row to top of window */ ! 892: if (row >= 0) { ! 893: ! 894: SendMessage(view->hwnd, TM_TOPROW, TRUE, row); ! 895: return; ! 896: } ! 897: } ! 898: } ! 899: ! 900: /*************************************************************************** ! 901: * Function: view_changediffoptions ! 902: * ! 903: * Purpose: ! 904: * ! 905: * The compare options have changed - re-do the compare completely ! 906: * and make the new mapping. Retain current position in the file. ! 907: */ ! 908: void ! 909: view_changediffoptions(VIEW view) ! 910: { ! 911: int state, number; ! 912: long row; ! 913: BOOL bRight; ! 914: LIST li; ! 915: COMPITEM ci; ! 916: ! 917: if (view == NULL) { ! 918: return; ! 919: } ! 920: ! 921: /* ! 922: * get current row before entering critsec. ! 923: */ ! 924: row = SendMessage(view->hwnd, TM_TOPROW, FALSE, 0); ! 925: ! 926: ViewEnter(); ! 927: ! 928: /* find the current line number so we can go back to it ! 929: * (only if we are in expanded mode ! 930: */ ! 931: if (view->bExpand) { ! 932: ! 933: state = section_getstate(view->pLines[row].section); ! 934: if ((state == STATE_MOVEDRIGHT) || ! 935: (state == STATE_RIGHTONLY)) { ! 936: bRight = TRUE; ! 937: number = view->pLines[row].nr_right; ! 938: } else { ! 939: bRight = FALSE; ! 940: number = view->pLines[row].nr_left; ! 941: } ! 942: } ! 943: ! 944: /* To force a recompare using the new options, we must ! 945: * tell each compitem to discard its current compare result. ! 946: * We need to traverse the list of compitems calling this ! 947: * for each compare. ! 948: */ ! 949: li = complist_getitems(view->cl); ! 950: ! 951: for (ci = (COMPITEM) List_First(li); ci != NULL; ci = (COMPITEM) List_Next(ci)) { ! 952: compitem_discardsections(ci); ! 953: } ! 954: ! 955: /* if we are in outline mode, we have nothing more to do */ ! 956: if (!view->bExpand) { ! 957: ViewLeave(); ! 958: return; ! 959: } ! 960: ! 961: view_expand_item(view, view->ciSelect); ! 962: ! 963: /* find the nearest row in the new view */ ! 964: ViewEnter(); ! 965: row = view_findrow(view, number, bRight); ! 966: ViewLeave(); ! 967: ! 968: /* scroll this row to top of window */ ! 969: if (row >= 0) { ! 970: SendMessage(view->hwnd, TM_TOPROW, TRUE, row); ! 971: } ! 972: } ! 973: ! 974: ! 975: /*************************************************************************** ! 976: * Function: view_findchange ! 977: * ! 978: * Purpose: ! 979: * ! 980: * Find the next changed - ie non-same - row in a given direction. ! 981: * For outline mode we find the next STATE_DIFFER. For expand mode, we ! 982: * find the next section ! 983: */ ! 984: long ! 985: view_findchange(VIEW view, long startrow, BOOL bForward) ! 986: { ! 987: long i; ! 988: ! 989: if (view == NULL) { ! 990: return(0); ! 991: } ! 992: ! 993: ViewEnter(); ! 994: ! 995: if (bForward) { ! 996: ! 997: if (startrow >= view->rows) { ! 998: ViewLeave(); ! 999: return(-1); ! 1000: } ! 1001: ! 1002: if (!view->bExpand) { ! 1003: ! 1004: /* look for next compitem with an expandable state*/ ! 1005: for (i = startrow; i < view->rows; i++) { ! 1006: if (compitem_getstate(view->pItems[i]) == STATE_DIFFER) { ! 1007: ViewLeave(); ! 1008: return(i); ! 1009: } ! 1010: } ! 1011: /* none found */ ! 1012: ViewLeave(); ! 1013: return(-1); ! 1014: } else { ! 1015: /* ! 1016: * find the next line that matches, then go on to the ! 1017: * next line that does not match ! 1018: * ! 1019: */ ! 1020: for (i= startrow; i < view->rows; i++) { ! 1021: if (section_getstate(view->pLines[i].section) ! 1022: == STATE_SAME) { ! 1023: break; ! 1024: } ! 1025: } ! 1026: for ( ; i < view->rows; i++) { ! 1027: if (section_getstate(view->pLines[i].section) ! 1028: != STATE_SAME) { ! 1029: ViewLeave(); ! 1030: return(i); ! 1031: } ! 1032: } ! 1033: ! 1034: ViewLeave(); ! 1035: ! 1036: return(-1); ! 1037: } ! 1038: } else { ! 1039: /* same search backwards */ ! 1040: if (startrow <= 0) { ! 1041: ViewLeave(); ! 1042: return(-1); ! 1043: } ! 1044: if (view->bExpand) { ! 1045: /* search backwards for first row that is not ! 1046: * changed (has state SAME). then carry on for ! 1047: * the next changed row. ! 1048: */ ! 1049: for (i = startrow; i >= 0; i--) { ! 1050: if (section_getstate(view->pLines[i].section) ! 1051: == STATE_SAME) { ! 1052: break; ! 1053: } ! 1054: } ! 1055: for ( ; i >= 0; i--) { ! 1056: if (section_getstate(view->pLines[i].section) ! 1057: != STATE_SAME) { ! 1058: ViewLeave(); ! 1059: return(i); ! 1060: } ! 1061: } ! 1062: ViewLeave(); ! 1063: return(-1); ! 1064: } else { ! 1065: for (i = startrow; i >= 0; i--) { ! 1066: if(compitem_getstate(view->pItems[i]) == STATE_DIFFER) { ! 1067: ViewLeave(); ! 1068: return(i); ! 1069: } ! 1070: } ! 1071: ViewLeave(); ! 1072: return(-1); ! 1073: } ! 1074: } ! 1075: } ! 1076: ! 1077: ! 1078: ! 1079: /*************************************************************************** ! 1080: * Function: view_findrow ! 1081: * ! 1082: * Purpose: ! 1083: * ! 1084: * Find the new row number for the line numbered 'number' ! 1085: * or the nearest line if possible. If bRight is true, number is ! 1086: * a right file number; otherwise it is a left file number. ! 1087: * ! 1088: * We must be in expand mode ! 1089: */ ! 1090: int ! 1091: view_findrow(VIEW view, int number, BOOL bRight) ! 1092: { ! 1093: int i; ! 1094: ! 1095: if (!view->bExpand) { ! 1096: return(0); ! 1097: } ! 1098: ! 1099: for (i = 0; i < view->rows; i++) { ! 1100: ! 1101: if (bRight) { ! 1102: if (view->pLines[i].nr_right == number) { ! 1103: ! 1104: /* found the exact number */ ! 1105: return(i); ! 1106: ! 1107: } else if (view->pLines[i].nr_right > number) { ! 1108: ! 1109: /* passed our line -stop here */ ! 1110: return(i); ! 1111: } ! 1112: } else { ! 1113: if (view->pLines[i].nr_left == number) { ! 1114: ! 1115: /* found the exact number */ ! 1116: return(i); ! 1117: ! 1118: } else if (view->pLines[i].nr_left > number) { ! 1119: ! 1120: /* passed our line -stop here */ ! 1121: return(i); ! 1122: } ! 1123: } ! 1124: } ! 1125: return(-1); ! 1126: } ! 1127: ! 1128: /*************************************************************************** ! 1129: * Function: view_freemappings ! 1130: * ! 1131: * Purpose: ! 1132: * ! 1133: * Free memory associated with the expand mode or outline mode mappings ! 1134: * called whenever we rebuild the mapping, and on deletion ! 1135: */ ! 1136: void ! 1137: view_freemappings(VIEW view) ! 1138: { ! 1139: ! 1140: if (view->pLines) { ! 1141: gmem_free(hHeap, (LPSTR) view->pLines, ! 1142: view->rows * sizeof(VIEWLINE)); ! 1143: view->pLines = NULL; ! 1144: } else if (view->pItems) { ! 1145: ! 1146: /* previous outline mapping array is still there - free it ! 1147: * before we build a new one ! 1148: */ ! 1149: ! 1150: gmem_free(hHeap, (LPSTR) view->pItems, ! 1151: view->rows * sizeof(COMPLIST)); ! 1152: view->pItems = NULL; ! 1153: } ! 1154: } ! 1155: ! 1156: /*************************************************************************** ! 1157: * Function: view_outline_opt ! 1158: * ! 1159: * Purpose: ! 1160: * ! 1161: * Build a view outline to map one row to a COMPITEM handle by traversing ! 1162: * the list of COMPITEMs obtained from our complist. ! 1163: * Optionally tell the table class to redraw (if bRedraw), and if so, ! 1164: * scroll the new table to select the row that represents the ! 1165: * file we were expanding, if possible ! 1166: */ ! 1167: void ! 1168: view_outline_opt(VIEW view, BOOL bRedraw) ! 1169: { ! 1170: int prev_row = -1; /* the row nr of the previously-expanded row*/ ! 1171: int i; /* nr of includable items */ ! 1172: LIST li; ! 1173: COMPITEM ci; ! 1174: int state; ! 1175: TableSelection select; ! 1176: ! 1177: /* ! 1178: * check that view_setcomplist has already been called. if not, ! 1179: * nothing to do ! 1180: */ ! 1181: if (view->cl == NULL) { ! 1182: return; ! 1183: } ! 1184: ! 1185: ViewEnter(); ! 1186: ! 1187: /* clear the mode flag and free up memory associated with expand mode */ ! 1188: view->bExpand = FALSE; ! 1189: view_freemappings(view); ! 1190: ! 1191: /* traverse the list of compitems counting up the number of ! 1192: * includable items ! 1193: */ ! 1194: li = complist_getitems(view->cl); ! 1195: ! 1196: ci = (COMPITEM) List_First(li); ! 1197: for (i = 0; ci != NULL; ci = (COMPITEM) List_Next(ci)) { ! 1198: ! 1199: state = compitem_getstate(ci); ! 1200: ! 1201: if (((outline_include & INCLUDE_SAME) && (state == STATE_SAME)) || ! 1202: ((outline_include & INCLUDE_DIFFER) && (state == STATE_DIFFER)) || ! 1203: ((outline_include & INCLUDE_LEFTONLY) && (state == STATE_FILELEFTONLY)) || ! 1204: ((outline_include & INCLUDE_RIGHTONLY) && (state == STATE_FILERIGHTONLY))) { ! 1205: i++; ! 1206: } ! 1207: } ! 1208: ! 1209: ! 1210: /* allocate an array big enough for all of these */ ! 1211: view->pItems = (COMPITEM FAR *) gmem_get(hHeap, i * sizeof(COMPITEM)); ! 1212: view->rows = i; ! 1213: ! 1214: /* keep track of the column widths */ ! 1215: view->maxtag = 0; ! 1216: view->maxrest = 0; ! 1217: ! 1218: /* loop through again filling the array, and at the same time looking ! 1219: * out for the handle of the previously expanded item ! 1220: */ ! 1221: ci = (COMPITEM) List_First(li); ! 1222: for (i = 0; ci != NULL; ci = (COMPITEM) List_Next(ci)) { ! 1223: ! 1224: state = compitem_getstate(ci); ! 1225: ! 1226: if (((outline_include & INCLUDE_SAME) && (state == STATE_SAME)) || ! 1227: ((outline_include & INCLUDE_DIFFER) && (state == STATE_DIFFER)) || ! 1228: ((outline_include & INCLUDE_LEFTONLY) && (state == STATE_FILELEFTONLY)) || ! 1229: ((outline_include & INCLUDE_RIGHTONLY) && (state == STATE_FILERIGHTONLY))) { ! 1230: ! 1231: view->pItems[i] = ci; ! 1232: ! 1233: if (ci == view->ciSelect) { ! 1234: prev_row = i; ! 1235: } ! 1236: ! 1237: /* check the column widths in characters */ ! 1238: view->maxtag = max(view->maxtag, ! 1239: lstrlen(compitem_gettext_tag(ci))); ! 1240: view->maxrest = max(view->maxrest, ! 1241: lstrlen(compitem_gettext_result(ci))); ! 1242: ! 1243: ! 1244: i++; ! 1245: ! 1246: } ! 1247: } ! 1248: ViewLeave(); ! 1249: ! 1250: /* inform table of new layout of table - force refresh */ ! 1251: if (bRedraw) { ! 1252: SendMessage(view->hwnd, TM_NEWLAYOUT, 0, (DWORD) view); ! 1253: ! 1254: /* scroll to and highlight the row that represents the file ! 1255: * we were previously expanding ! 1256: */ ! 1257: if (prev_row != -1) { ! 1258: select.startrow = prev_row; ! 1259: select.startcell = 0; ! 1260: select.nrows = 1; ! 1261: select.ncells = 1; ! 1262: SendMessage(view->hwnd, TM_SELECT, 0, ! 1263: (DWORD) (LPSTR) &select); ! 1264: } ! 1265: } ! 1266: } ! 1267: ! 1268: ! 1269: /*************************************************************************** ! 1270: * Function: view_expand_item ! 1271: * ! 1272: * Purpose: ! 1273: * ! 1274: * Expand a view - given the handle to the compitem to expand. ! 1275: * ! 1276: * Called from view_expand, and also to re-do an expanded view ! 1277: * after options change in view_changediffoptions and _changeviewoptions ! 1278: * ! 1279: * We get the composite section list from the compitem, ! 1280: * and pick out all the sections that are includable (according ! 1281: * to the global option expand_mode: we include all sections, or ! 1282: * just those in one side left or right). Once we know the count of rows, ! 1283: * allocate the mapping array: in each element of the array we keep ! 1284: * a handle to the section for that row (to get the state and hence the ! 1285: * tag text), and a handle to the line within that section (for the line text). ! 1286: * ! 1287: * We no longer insist on only expanding text files that differ - if the ! 1288: * compitem can give us a composite section list, we will map it. ! 1289: * ! 1290: * We need to be able to give a line number for a line, in either of ! 1291: * the original files according to which option is in force. Each section ! 1292: * can give us its base line number (number of first line in section) in ! 1293: * each of the two files or 0 if not present, and we track these here. ! 1294: * ! 1295: * MUST BE INSIDE CSView BEFORE CALLING HERE. ! 1296: */ ! 1297: BOOL ! 1298: view_expand_item(VIEW view, COMPITEM ci) ! 1299: { ! 1300: LIST li; ! 1301: SECTION sh; ! 1302: LINE line1, line2; ! 1303: int i, base_left, base_right, state; ! 1304: ! 1305: /* remember the compitem we are expanding */ ! 1306: view->ciSelect = ci; ! 1307: ! 1308: /* get the composite section list */ ! 1309: li = compitem_getcomposite(view->ciSelect); ! 1310: if (li == NULL) { ! 1311: ViewLeave(); ! 1312: return FALSE; ! 1313: } ! 1314: ! 1315: /* switch modes and free the current mapping ! 1316: * ! 1317: * NOTE: must do this AFTER the compitem_getcomposite, ! 1318: * since that can fail: if it fails it could put up a ! 1319: * message box, and that could cause a queued paint message ! 1320: * to be processed, which would cause us to use these mappings ! 1321: * and gpfault if they had been cleared first. ! 1322: */ ! 1323: view->bExpand = TRUE; ! 1324: view_freemappings(view); ! 1325: ! 1326: ! 1327: /* loop through totalling the lines in sections ! 1328: * that we should include ! 1329: */ ! 1330: view->rows = 0; ! 1331: for (sh = (SECTION) List_First(li); sh != NULL; ! 1332: sh = (SECTION) List_Next(sh)) { ! 1333: ! 1334: state = section_getstate(sh); ! 1335: ! 1336: if (expand_mode == IDM_RONLY) { ! 1337: if ((state == STATE_LEFTONLY) || ! 1338: (state == STATE_MOVEDLEFT)) { ! 1339: continue; ! 1340: } ! 1341: } else if (expand_mode == IDM_LONLY) { ! 1342: if ((state == STATE_RIGHTONLY) || ! 1343: (state == STATE_MOVEDRIGHT)) { ! 1344: continue; ! 1345: } ! 1346: } ! 1347: ! 1348: /* include all lines in this section */ ! 1349: view->rows += section_getlinecount(sh); ! 1350: } ! 1351: ! 1352: /* allocate the memory for the mapping array */ ! 1353: view->pLines = (PVIEWLINE) gmem_get(hHeap, view->rows * sizeof(VIEWLINE)); ! 1354: ! 1355: /* loop through the sections again filling in the mapping array */ ! 1356: i = 0; ! 1357: view->maxtag = 5; ! 1358: view->maxrest = 0; ! 1359: for (sh = (SECTION) List_First(li); sh != NULL; ! 1360: sh = (SECTION) List_Next(sh)) { ! 1361: ! 1362: state = section_getstate(sh); ! 1363: ! 1364: if (expand_mode == IDM_RONLY) { ! 1365: if ((state == STATE_LEFTONLY) || ! 1366: (state == STATE_MOVEDLEFT)) { ! 1367: continue; ! 1368: } ! 1369: } else if (expand_mode == IDM_LONLY) { ! 1370: if ((state == STATE_RIGHTONLY) || ! 1371: (state == STATE_MOVEDRIGHT)) { ! 1372: continue; ! 1373: } ! 1374: } ! 1375: ! 1376: /* find the base line number in each file */ ! 1377: base_left = section_getleftbasenr(sh); ! 1378: base_right = section_getrightbasenr(sh); ! 1379: ! 1380: /* add each line in section to the view. section_getfirst() ! 1381: * returns us to a handle that is in a list. We can ! 1382: * call List_Next and will eventually get to the ! 1383: * line returned by section_getlast(). Sections always have ! 1384: * at least one line ! 1385: */ ! 1386: line1 = section_getfirstline(sh); ! 1387: line2 = section_getlastline(sh); ! 1388: ! 1389: for (; line1 != NULL; line1 = (LINE) List_Next(line1)) { ! 1390: ! 1391: view->pLines[i].line = line1; ! 1392: view->pLines[i].section = sh; ! 1393: ! 1394: /* calculate the line number for this line by ! 1395: * incrementing the base nr for this section ! 1396: */ ! 1397: ! 1398: view->pLines[i].nr_left = base_left; ! 1399: if (base_left != 0) { ! 1400: base_left++; ! 1401: } ! 1402: ! 1403: view->pLines[i].nr_right = base_right; ! 1404: if (base_right != 0) { ! 1405: base_right++; ! 1406: } ! 1407: ! 1408: /* increment index into view */ ! 1409: i++; ! 1410: ! 1411: /* check the column widths */ ! 1412: view->maxrest = max(view->maxrest, ! 1413: (line_gettabbedlength(line1, 8))); ! 1414: ! 1415: /* end of section ? */ ! 1416: if (line1 == line2) { ! 1417: break; ! 1418: } ! 1419: } ! 1420: } ! 1421: ! 1422: /* We must NOT hold a critical section here as SendMessage may hang */ ! 1423: ViewLeave(); ! 1424: ! 1425: /*inform table window of revised mapping */ ! 1426: SendMessage(view->hwnd, TM_NEWLAYOUT, 0, (DWORD) view); ! 1427: ! 1428: return(TRUE); ! 1429: } ! 1430:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.