home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sdktools / windiff / bar.c next >
C/C++ Source or Header  |  1997-10-05  |  20KB  |  637 lines
  1.  
  2. /******************************************************************************\
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 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: BAR.C
  14. *
  15. * This module contains functions for bar window 
  16. * graphically showing two lists of sections and showing 
  17. * colored vertical bars for the sections of text,
  18. * with linking lines for the sections that are the same.
  19. *
  20. * Functions:
  21. *
  22. * BarWndProc()
  23. * BarPaint()
  24. * DrawSection()
  25. * DrawLink()
  26. * BarClick() 
  27. * InitBarClass()
  28. * BarDrawPosition()
  29. * 
  30. * Comments:
  31. *
  32. ****************************************************************************/
  33.  
  34. #include <windows.h>
  35. #include <commdlg.h>
  36.  
  37. #include "gutils.h"
  38. #include "table.h"
  39. #include "state.h"
  40. #include "wdiffrc.h"
  41. #include "windiff.h"
  42. #include "list.h"
  43. #include "line.h"
  44. #include "scandir.h"
  45. #include "file.h"
  46. #include "section.h"
  47. #include "compitem.h"
  48. #include "complist.h"
  49. #include "view.h"
  50.  
  51.  
  52. long APIENTRY BarWndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam);
  53. void BarPaint(HWND hwnd);
  54. void DrawSection(HDC hdc, int cx, int cy, int lines, SECTION sec, int sidecode);
  55. void DrawLink(HDC hdc, int cx, int cy, int lines, SECTION sec);
  56. void BarClick(HWND hwnd, int x, int y);
  57.  
  58.  
  59. HPEN hpenSame, hpenLeft, hpenRight;
  60. HBRUSH hbrSame, hbrLeft, hbrRight;
  61. HBRUSH hbrSideBar;
  62.  
  63.  
  64. /***************************************************************************
  65.  * Function: InitBarClass
  66.  *
  67.  * Purpose:
  68.  *
  69.  * Create bar window class
  70.  */
  71. BOOL
  72. InitBarClass(HINSTANCE hInstance)
  73. {
  74.         WNDCLASS    wc;
  75.         BOOL resp;
  76.  
  77.  
  78.  
  79.         wc.style = CS_HREDRAW | CS_VREDRAW;
  80.         wc.lpfnWndProc = BarWndProc;
  81.         wc.cbClsExtra = 0;
  82.         wc.cbWndExtra = 0;
  83.         wc.hInstance = hInstance;
  84.         wc.hIcon = NULL;
  85.         wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  86.         wc.hbrBackground = GetStockObject(WHITE_BRUSH);
  87.         wc.lpszClassName = "BarClass";
  88.         wc.lpszMenuName = NULL;
  89.  
  90.         resp = RegisterClass(&wc);
  91.  
  92.         return(resp);
  93. }
  94.  
  95.  
  96.  
  97. /***************************************************************************
  98.  * Function: BarWndProc
  99.  *
  100.  * Purpose:
  101.  *
  102.  * Window procedure supporting bar window
  103.  *
  104.  */
  105.  
  106. long APIENTRY
  107. BarWndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam)
  108. {
  109.  
  110.         switch(message) {
  111.  
  112.  
  113.         case WM_CREATE:
  114.  
  115.                 hpenSame = CreatePen(PS_SOLID, 1, RGB(0,0,0));
  116.                 hbrSame = CreateSolidBrush(RGB(255,255,255));
  117.  
  118.                 hpenLeft = CreatePen(PS_SOLID, 1, rgb_barleft);
  119.                 hbrLeft = CreateSolidBrush(rgb_barleft);
  120.  
  121.                 hpenRight = CreatePen(PS_SOLID, 1, rgb_barright);
  122.                 hbrRight = CreateSolidBrush(rgb_barright);
  123.  
  124.                 hbrSideBar = CreateSolidBrush(rgb_barcurrent);
  125.                 break;
  126.  
  127.         case WM_DESTROY:
  128.                 DeleteObject(hpenSame);
  129.                 DeleteObject(hpenLeft);
  130.                 DeleteObject(hpenRight);
  131.                 DeleteObject(hbrSame);
  132.                 DeleteObject(hbrLeft);
  133.                 DeleteObject(hbrRight);
  134.                 DeleteObject(hbrSideBar);
  135.                 break;
  136.  
  137.         case WM_PAINT:
  138.                 BarPaint(hWnd);
  139.                 break;
  140.  
  141.         case WM_LBUTTONDOWN:
  142.                 BarClick(hWnd, LOWORD(lParam), HIWORD(lParam));
  143.                 break;
  144.  
  145.         default:
  146.                 return(DefWindowProc(hWnd, message, wParam, lParam));
  147.         }
  148.         return 0;
  149. }
  150.  
  151. /***************************************************************************
  152.  * Function: BarDrawPosition
  153.  *
  154.  * Purpose:
  155.  *
  156.  * Draw the current position as side-bars down the bar window,
  157.  * showing which lines from each file are currently in view. HDC can be
  158.  * NULL (we get one ourselves if so). If bErase is true, we clear
  159.  * the previous side-bars first.
  160.  *
  161.  * This is called from BarPaint when we paint the whole window, and
  162.  * from TableServer() whenever it receives a TQ_SCROLL notification that
  163.  * the table window has been scrolled.
  164.  */
  165. void
  166. BarDrawPosition(HWND hwndBar, HDC hdcIn, BOOL bErase)
  167. {
  168.         HDC hdc;
  169.         int total_lines, cy, cx;
  170.         RECT rc, rcLeft, rcRight;
  171.         VIEW view;
  172.         COMPITEM item;
  173.         LIST listleft, listright;
  174.         long toprow, endrow, i;
  175.         int left_first, left_last, right_first, right_last, linenr;
  176.  
  177.  
  178.         /* get a hdc if we weren't given one */
  179.         if (hdcIn == NULL) {
  180.                 hdc = GetDC(hwndBar);
  181.         } else {
  182.                 hdc = hdcIn;
  183.         }
  184.  
  185.         /* set horz position of bars */
  186.         GetClientRect(hwndBar, &rc);
  187.         cx = (int)(rc.right - rc.left);
  188.         cy = (int)(rc.bottom - rc.top);
  189.  
  190.         /* layout constants are defined as percentages of window width */
  191.         rcLeft.left = cx * L_POS_START / 100;
  192.         rcRight.left = cx * R_POS_START / 100;
  193.         rcLeft.right = rcLeft.left +  (cx * L_POS_WIDTH / 100);
  194.         rcRight.right = rcRight.left +  (cx * R_POS_WIDTH / 100);
  195.  
  196.         /* erase the whole marker section if requested */
  197.         if (bErase) {
  198.                 rcLeft.top = rc.top;
  199.                 rcLeft.bottom = rc.bottom;
  200.                 rcRight.top = rc.top;
  201.                 rcRight.bottom = rc.bottom;
  202.  
  203.                 FillRect(hdc, &rcLeft, GetStockObject(WHITE_BRUSH));
  204.  
  205.                 FillRect(hdc, &rcRight, GetStockObject(WHITE_BRUSH));
  206.         }
  207.  
  208.  
  209.         /*
  210.          * calculate the vertical scaling - depends on the
  211.          * total number of lines shown
  212.          */
  213.  
  214.         /* get the handles to the two lists of sections */
  215.         view = (VIEW) SendMessage(hwndClient, TM_CURRENTVIEW, 0, 0);
  216.         /* make sure we are in expand mode */
  217.         if (view_isexpanded(view) == FALSE) {
  218.                 /* get rid of the dc if we made it ourselves */
  219.                 if (hdcIn == NULL) {
  220.                         ReleaseDC(hwndBar, hdc);
  221.                 }
  222.                 return;
  223.         }
  224.  
  225.         item = view_getitem(view, 0);
  226.  
  227.         listleft = compitem_getleftsections(item);
  228.         listright = compitem_getrightsections(item);
  229.  
  230.         /* if there is only one list of sections, draw nothing. The
  231.          * picture for a single file is not very exciting.
  232.          */
  233.  
  234.         if ((listleft == NULL) || (listright == NULL)) {
  235.                 /* get rid of the dc if we made it ourselves */
  236.                 if (hdcIn == NULL) {
  237.                         ReleaseDC(hwndBar, hdc);
  238.                 }
  239.                 return;
  240.         }
  241.  
  242.         /* take the longest of the two files and use this
  243.          * for vertical scaling. the scale is such that the longest file
  244.          * *just fits*.
  245.          */
  246.         total_lines = line_getlinenr(section_getlastline(List_Last(listleft)));
  247.         total_lines = max(total_lines,
  248.                        (int) line_getlinenr(section_getlastline(List_Last(listright))));
  249.  
  250.  
  251.         /* get the current top row and nr of rows visible */
  252.         toprow = SendMessage(hwndRCD, TM_TOPROW, FALSE, 0);
  253.         endrow = SendMessage(hwndRCD, TM_ENDROW, FALSE, 0);
  254.         endrow = min(endrow, view_getrowcount(view)-1);
  255.  
  256.  
  257.  
  258.         /*
  259.          * find the first and last line nrs from each file currently visible.
  260.          *
  261.          */
  262.         left_first = left_last = right_first = right_last = 0;
  263.  
  264.         for (i = toprow; i <= endrow; i++) {
  265.                 linenr = view_getlinenr_left(view, i);
  266.  
  267.                 if (linenr > 0) {
  268.  
  269.                         if (left_first == 0) {
  270.                                 left_first = linenr;
  271.                         }
  272.                         left_first = min(left_first, linenr);
  273.                         left_last = max(left_last, linenr);
  274.                 }
  275.  
  276.                 linenr = view_getlinenr_right(view, i);
  277.                 if (linenr > 0) {
  278.                         if (right_first == 0) {
  279.                                 right_first = linenr;
  280.                         }
  281.                         right_first = min(right_first, linenr);
  282.                         right_last = max(right_last, linenr);
  283.                 }
  284.  
  285.         }
  286.  
  287.         /* draw the two markers as thick bars -> elongated rectangles */
  288.         rcLeft.top = MulDiv(left_first-1, cy, total_lines);
  289.         rcLeft.bottom = MulDiv(left_last, cy, total_lines);
  290.         FillRect(hdc, &rcLeft, hbrSideBar);
  291.  
  292.         rcRight.top = MulDiv(right_first-1, cy, total_lines);
  293.         rcRight.bottom = MulDiv(right_last, cy, total_lines);
  294.         FillRect(hdc, &rcRight, hbrSideBar);
  295.  
  296.         /* get rid of the dc if we made it ourselves */
  297.         if (hdcIn == NULL) {
  298.                 ReleaseDC(hwndBar, hdc);
  299.         }
  300.  
  301. }
  302.  
  303.  
  304. /***************************************************************************
  305.  * Function: BarPaint
  306.  *
  307.  * Purpose:
  308.  *
  309.  * Paint the bar window 
  310.  */
  311. void
  312. BarPaint(HWND hwnd)
  313. {
  314.         PAINTSTRUCT ps;
  315.         HDC hdc;
  316.         VIEW view;
  317.         COMPITEM item;
  318.         LIST listleft, listright;
  319.         SECTION sec;
  320.         int total_lines, cx, cy;
  321.         RECT rc;
  322.  
  323.         hdc = BeginPaint(hwnd, &ps);
  324.  
  325.         /* draw a separator line at the very edge of the window */
  326.         GetClientRect(hwnd, &rc);
  327.         MoveToEx(hdc, (int)(rc.right-1), rc.top, NULL);
  328.         LineTo(hdc, (int)(rc.right-1), rc.bottom);
  329.  
  330.  
  331.         /* first gather information about what is to be displayed */
  332.  
  333.         /* find the total lines (for horz. scaling) */
  334.  
  335.         /* get the handles to the two lists of sections */
  336.         view = (VIEW) SendMessage(hwndClient, TM_CURRENTVIEW, 0, 0);
  337.  
  338.         /* make sure we are in expand mode */
  339.         if (view_isexpanded(view) == FALSE) {
  340.                 return;
  341.         }
  342.  
  343.         item = view_getitem(view, 0);
  344.  
  345.         listleft = compitem_getleftsections(item);
  346.         listright = compitem_getrightsections(item);
  347.  
  348.         /*
  349.          * don't bother if there is only one list - not very interesting
  350.          */
  351.         if ((listleft == NULL) || (listright == NULL)) {
  352.                 EndPaint(hwnd, &ps);
  353.                 return;
  354.         }
  355.  
  356.         /* take the longest of the two files and use this
  357.          * for vertical scaling. the scale is such that the longest file
  358.          * *just fits*.
  359.          */
  360.         total_lines = (int) line_getlinenr(section_getlastline(List_Last(listleft)));
  361.         total_lines = max(total_lines,
  362.                        (int) line_getlinenr(section_getlastline(List_Last(listright))));
  363.  
  364.  
  365.  
  366.         /* horizontal spacing:
  367.          *
  368.          * there are two columns, for the left and right files, and a gap
  369.          * between them criss-crossed by lines marking the links.
  370.          *
  371.          * Each of the columns then has three sections, for the
  372.          * position marker, the different sections
  373.          * and the linked sections. The width and positions of these items
  374.          * are defined (in windiff.h) as percentages of the window width.
  375.          */
  376.  
  377.         cx = (int)(rc.right - rc.left);
  378.         cy = (int)(rc.bottom - rc.top);
  379.  
  380.  
  381.         /* draw all the left sections and links */
  382.         List_TRAVERSE(listleft, sec) {
  383.                 DrawSection(hdc, cx, cy, total_lines, sec, STATE_LEFTONLY);
  384.  
  385.                 if (section_getlink(sec) != NULL) {
  386.                         DrawLink(hdc, cx, cy, total_lines, sec);
  387.                 }
  388.         }
  389.  
  390.         /* draw all the right sections */
  391.         List_TRAVERSE(listright, sec) {
  392.                 DrawSection(hdc, cx, cy, total_lines, sec, STATE_RIGHTONLY);
  393.         }
  394.  
  395.  
  396.  
  397.         /* now draw current position markers */
  398.         BarDrawPosition(hwnd, hdc, FALSE);
  399.  
  400.         EndPaint(hwnd, &ps);
  401. }
  402.  
  403. /***************************************************************************
  404.  * Function: DrawSection
  405.  *
  406.  * Purpose:
  407.  *
  408.  * Paint a single section 
  409.  */
  410. void
  411. DrawSection(HDC hdc, int cx, int cy, int lines, SECTION sec, int sidecode)
  412. {
  413.         int x1, y1, x2, y2;
  414.         HPEN hpenOld;
  415.         HBRUSH hbrOld;
  416.  
  417.         /* calculate the vertical position from the scaling. the scaling
  418.          * is such that the longest file just fits
  419.          */
  420.         y1 = MulDiv(line_getlinenr(section_getfirstline(sec))- 1, cy, lines);
  421.         y2 = MulDiv(line_getlinenr(section_getlastline(sec)), cy, lines);
  422.  
  423.  
  424.         /* left or right  - set bar position and width*/
  425.         if (sidecode == STATE_LEFTONLY) {
  426.                 if (section_getlink(sec) != NULL) {
  427.                         x1 = L_MATCH_START;
  428.                         x2 = L_MATCH_WIDTH;
  429.                 } else {
  430.                         x1 = L_UNMATCH_START;
  431.                         x2 = L_UNMATCH_WIDTH;
  432.                 }
  433.         } else {
  434.                 if (section_getlink(sec) != NULL) {
  435.                         x1 = R_MATCH_START;
  436.                         x2 = R_MATCH_WIDTH;
  437.                 } else {
  438.                         x1 = R_UNMATCH_START;
  439.                         x2 = R_UNMATCH_WIDTH;
  440.                 }
  441.         }
  442.         /* bar position defines are in percentages of the win width (cx) */
  443.         x1 = cx * x1 / 100;
  444.         x2 = (cx * x2 / 100) + x1;
  445.  
  446.  
  447.         /* select pens and brushes */
  448.         if (section_getlink(sec) != NULL) {
  449.                 hpenOld = SelectObject(hdc, hpenSame);
  450.                 hbrOld = SelectObject(hdc, hbrSame);
  451.         } else if (sidecode == STATE_LEFTONLY) {
  452.                 hpenOld = SelectObject(hdc, hpenLeft);
  453.                 hbrOld = SelectObject(hdc, hbrLeft);
  454.         } else {
  455.                 hpenOld = SelectObject(hdc, hpenRight);
  456.                 hbrOld = SelectObject(hdc, hbrRight);
  457.         }
  458.  
  459.         /* draw the section as a coloured elongated rectangle */
  460.         Rectangle(hdc, x1, y1, x2, y2);
  461.  
  462.         /* de-select the pen and brush in favour of the default */
  463.         SelectObject(hdc, hpenOld);
  464.         SelectObject(hdc, hbrOld);
  465.  
  466. }
  467.  
  468. /***************************************************************************
  469.  * Function: DrawLink
  470.  *
  471.  * Purpose:
  472.  *
  473.  * Draw a line linking two sections. Indicates a section from each
  474.  * file that match each other. psec points to the section in the
  475.  * left file.
  476.  */
  477. void
  478. DrawLink(HDC hdc, int cx, int cy, int lines, SECTION sec)
  479. {
  480.         int x1, y1, x2, y2;
  481.         int ybase, yrange;
  482.         SECTION other;
  483.  
  484.         other = section_getlink(sec);
  485.  
  486.         /* position the link line halfway down the section
  487.          * - allow for the case where
  488.          * the section is one line (ie halve the co-ords, not the line nr)
  489.          */
  490.         ybase = MulDiv(line_getlinenr(section_getfirstline(sec)) - 1, cy, lines);
  491.         yrange = MulDiv(line_getlinenr(section_getlastline(sec)), cy, lines);
  492.         y1 = ((yrange - ybase) / 2) + ybase;
  493.  
  494.         ybase = MulDiv(line_getlinenr(section_getfirstline(other)) - 1, cy, lines);
  495.         yrange = MulDiv(line_getlinenr(section_getlastline(other)), cy, lines);
  496.         y2 = ((yrange - ybase) / 2) + ybase;
  497.  
  498.         /* horizontal layout constants are defined as percentages of the
  499.          * window width
  500.          */
  501.         x1 = cx * (L_MATCH_START + L_MATCH_WIDTH) / 100;
  502.         x2 = cx * R_UNMATCH_START / 100;
  503.  
  504.         MoveToEx(hdc, x1, y1, NULL);
  505.         LineTo(hdc, x2, y2);
  506. }
  507.  
  508.  
  509. /***************************************************************************
  510.  * Function: BarClick
  511.  *
  512.  * Purpose:
  513.  *
  514.  * The user has clicked on the bar window. Translate the clicked position into
  515.  * a line in one of the files if possible, and scroll the table window to
  516.  * show that line.
  517.  */
  518. void
  519. BarClick(HWND hwnd, int x, int y)
  520. {
  521.         RECT rc;
  522.         int xleft, xright;
  523.         int linenr, i, this;
  524.         BOOL bIsLeft;
  525.         int tot_left, tot_right, total_lines;
  526.         LIST listleft, listright;
  527.         VIEW view;
  528.         COMPITEM item;
  529.         TableSelection select;
  530.  
  531.  
  532.         /* find size of the window to get horz scaling, and see
  533.          * where click was
  534.          */
  535.         GetClientRect(hwnd, &rc);
  536.  
  537.         /* was it near either of the bars ? */
  538.  
  539.         /* horz positioning is in percentages of window width */
  540.         xleft = max(L_UNMATCH_START + L_UNMATCH_WIDTH,
  541.                      L_MATCH_START + L_MATCH_WIDTH);
  542.         xright = min(R_UNMATCH_START, R_MATCH_START);
  543.         xleft = xleft * (rc.right - rc.left) / 100;
  544.         xright = xright * (rc.right - rc.left) / 100;
  545.  
  546.  
  547.         if (x < xleft) {
  548.                 bIsLeft = TRUE;
  549.         } else if (x > xright) {
  550.                 bIsLeft = FALSE;
  551.         } else {
  552.                 /* click was between the two bars - ignore it */
  553.                 return;
  554.         }
  555.  
  556.  
  557.         /* calculate the vertical scaling (based on total lines displayed)
  558.          * so that we can convert the y position into a line nr
  559.          */
  560.  
  561.         /* get the handles to the two lists of sections */
  562.         view = (VIEW) SendMessage(hwndClient, TM_CURRENTVIEW, 0, 0);
  563.  
  564.         /* make sure we are in expand mode */
  565.         if (view_isexpanded(view) == FALSE) {
  566.                 return;
  567.         }
  568.  
  569.         item = view_getitem(view, 0);
  570.  
  571.         listleft = compitem_getleftsections(item);
  572.         listright = compitem_getrightsections(item);
  573.  
  574.         /* ignore the click if only one list of sections, since in
  575.          * this case there is nothing drawn for him to click on.
  576.          */
  577.         if ((listleft == NULL) || (listright == NULL)) {
  578.                 return;
  579.         }
  580.  
  581.         /* take the longest of the two files and use this
  582.          * for vertical scaling. the scale is such that the longest file
  583.          * *just fits*.
  584.          */
  585.         tot_left = line_getlinenr(section_getlastline(List_Last(listleft)));
  586.         tot_right = line_getlinenr(section_getlastline(List_Last(listright)));
  587.  
  588.         total_lines = max(tot_left, tot_right);
  589.  
  590.  
  591.         /* convert vertical position into a line nr. The vertical scaling
  592.          * can be calculated from knowing that the longest list of
  593.          * lines just fits in the window.
  594.          */
  595.         linenr = (int) (((long) total_lines * y) / (rc.bottom - rc.top)) + 1;
  596.  
  597.         /* check that the line is valid */
  598.         if (bIsLeft) {
  599.                 if (linenr > tot_left) {
  600.                         return;
  601.                 }
  602.         } else {
  603.                 if (linenr > tot_right) {
  604.                         return;
  605.                 }
  606.         }
  607.  
  608.         /* search the current view, looking for a row with this
  609.          * line nr on the correct side
  610.          */
  611.         for (i = 0; i < view_getrowcount(view); i++) {
  612.                 if (bIsLeft) {
  613.                         this = view_getlinenr_left(view,i);
  614.                 } else {
  615.                         this = view_getlinenr_right(view,i);
  616.                 }
  617.  
  618.                 if (linenr == this) {
  619.                         /* found the matching line- select it in the
  620.                          * table window
  621.                          */
  622.                         select.startrow = i;
  623.                         select.startcell = 0;
  624.                         select.nrows = 1;
  625.                         select.ncells = 1;
  626.                         SendMessage(hwndRCD, TM_SELECT, 0, (long) (LPSTR)&select);
  627.                         return;
  628.                 }
  629.         }
  630.  
  631.         windiff_UI(TRUE);
  632.         MessageBox(hwndClient, LoadRcString(IDS_LINE_NOT_VISIBLE),
  633.                 "WinDiff", MB_ICONSTOP|MB_OK);
  634.         windiff_UI(FALSE);
  635. }
  636.  
  637.