![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to listwin.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview|
Return to listwin.cpp CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview |
1.1 root 1: #include <afxwin.h>
2: #include <afxdlgs.h>
3: #include <afxcoll.h>
4: #include <string.h>
5:
6: #include "types.h"
7: #include "resource.h"
8: #include "ranges.h"
9: #include "list.h"
10: #include "listwin.h"
11:
12:
13: #define PAGESIZE 8
14:
15: /*********************** GLOBAL DATA *****************************/
16:
17: extern LOGFONT DefaultFont;
18: extern HCURSOR HCursorSizer;
19: extern HCURSOR HCursorNormal;
20: extern HICON HIconList;
21:
22:
23: /*********************** CListWnd implementation **********************/
24:
25: BEGIN_MESSAGE_MAP(CListWnd, CMDIChildWnd)
26: ON_WM_CREATE()
27: ON_WM_DESTROY()
28: ON_WM_MDIACTIVATE()
29: ON_WM_KEYDOWN()
30: ON_WM_LBUTTONDBLCLK()
31: ON_WM_LBUTTONDOWN()
32: ON_WM_LBUTTONUP()
33: ON_WM_MOUSEMOVE()
34: ON_WM_PAINT()
35: ON_WM_SIZE()
36: ON_WM_VSCROLL()
37:
38: ON_COMMAND( VK_UP, OnUp )
39: ON_COMMAND( VK_DOWN, OnDown )
40: ON_COMMAND( IDM_LIST_FONT, OnFont )
41: ON_COMMAND( IDM_LIST_RANGES, OnRanges )
42: ON_COMMAND( IDM_LIST_ALPHA, OnSortAlpha )
43: ON_COMMAND( IDM_LIST_CALLS, OnSortCalls )
44: ON_COMMAND( IDM_LIST_TIME, OnSortTime )
45: ON_COMMAND( IDM_LIST_PER_CALL, OnSortTimePer)
46: ON_COMMAND( IDM_LIST_CHILDREN, OnChildren)
47: END_MESSAGE_MAP()
48:
49: BOOL CListWnd::Create(LPCSTR szTitle, LONG style, const RECT& rect,
50: CMDIFrameWnd* parent)
51: {
52: const char * pszStockClass = AfxRegisterWndClass(
53: CS_HREDRAW | CS_VREDRAW, NULL,
54: (HBRUSH) (COLOR_WINDOW+1), HIconList);
55:
56: rgl[0] = 0;
57: rgl[1] = 150;
58: rgl[2] = 200;
59: rgl[3] = 250;
60: rgl[4] = 300;
61: rgl[5] = 350;
62: rgl[6] = 400;
63: rgl[7] = 450;
64: rgl[8] = 500;
65: rgl[9] = 550;
66: rgl[10] = 600;
67: m_cxClient = 600;
68: fCapture = FALSE;
69:
70: return CMDIChildWnd::Create(pszStockClass, szTitle, style, rect, parent);
71: }
72:
73:
74: CListWnd::CListWnd()
75: {
76: int i;
77:
78: m_pMenuCurrent = NULL;
79: m_bWindowActive = FALSE;
80: m_SortOrder = LIST_ALPHA;
81: logFont = DefaultFont;
82: fChildren = FALSE;
83:
84: for (i=0; i<MAX_NUM_RANGES; i++) {
85: rs.TextColor[i] = 0;
86: rs.BackColor[i] = RGB( 0, 0, 0);
87: rs.Above[i] = 101;
88: }
89:
90: rs.Above[0] = 0; rs.BackColor[0] = RGB( 0, 0, 255);
91: rs.TextColor[0] = 1;
92: rs.Above[1] = 1; rs.BackColor[1] = RGB( 0, 255, 0);
93: rs.Above[2] = 2; rs.BackColor[2] = RGB( 0, 255, 255);
94: rs.Above[3] = 5; rs.BackColor[3] = RGB( 255, 255, 0);
95: rs.Above[4] = 20; rs.BackColor[4] = RGB( 255, 0, 0);
96: rs.Above[5] = 101;
97: rs.cRanges = 5;
98:
99: ratio = 0.33;
100:
101: return;
102: } /* CListWnd::CListWnd() */
103:
104: CListWnd::~CListWnd()
105: {
106: if (m_bWindowActive) {
107: m_pMenuCurrent->Detach();
108: }
109: }
110:
111: void CListWnd::EndTiming()
112: {
113: m_ListHead.SortByTotalTime();
114: m_ListHead.SortByPerTime();
115: m_ListHead.SortByCallCount();
116: m_ListHead.SortByTPerTime();
117: m_ListHead.SortByTimeAll();
118: pRight->ComputeWidths();
119: pLeft->ComputeWidths();
120: return;
121: }
122:
123: void CListWnd::InvalidateLine()
124: {
125: CRect area(0, (m_nSelectLine - m_nVscrollPos ) * m_cyChar,
126: m_cxClient, (m_nSelectLine + 1 - m_nVscrollPos) * m_cyChar);
127: InvalidateRect( area );
128: }
129:
130: int CListWnd::OnCreate(LPCREATESTRUCT p)
131: {
132: TEXTMETRIC tm;
133:
134: CDC * dc = GetDC();
135: dc->GetTextMetrics( &tm );
136: ReleaseDC( dc );
137:
138: m_cxChar = tm.tmAveCharWidth;
139: m_cxCaps = ( (tm.tmPitchAndFamily & 1) ? 3 : 2) * m_cxChar / 2;
140: m_cyChar = tm.tmHeight + tm.tmExternalLeading;
141: m_nMaxWidth = ( 20 ) * m_cxCaps;
142: m_nVscrollPos = 0;
143:
144: /*
145: */
146:
147: pLeft = new CListWndLeft;
148: pLeft->Create(WS_HSCROLL|WS_VISIBLE, rectDefault, this);
149:
150: pRight = new CListWndRight;
151: pRight->Create(WS_HSCROLL|WS_VISIBLE, rectDefault, this);
152:
153: return 0;
154: }
155:
156:
157: void CListWnd::OnDestroy()
158: {
159: // m_pMDIFrameWnd->SendMessage(WM_CHILDDESTROY, (UINT)m_hWnd, 0);
160: return;
161: }
162:
163:
164: void CListWnd::OnSize(UINT nType, int cx, int cy)
165: {
166: int cxOld = m_cxClient;
167: int i;
168:
169: i = (int) (cx*ratio);
170: pLeft->MoveWindow(0, 0, i-1, cy);
171: pRight->MoveWindow(i+2, 0, cx-(i+2), cy);
172:
173: /*
174: * Now set the scroll ranges
175: */
176:
177: m_cxClient = cx;
178: m_cyClient = max(cy, 1);
179:
180: m_nVscrollMax = max( 0, (int)( m_ListHead.GetCount() ) - m_cyClient / m_cyChar );
181: m_nVscrollPos = min( m_nVscrollPos, m_nVscrollMax );
182:
183: SetScrollRange( SB_VERT, 0, m_nVscrollMax, FALSE );
184: SetScrollPos( SB_VERT, m_nVscrollPos, TRUE );
185:
186: CMDIChildWnd::OnSize(nType, cx, cy);
187:
188: return;
189: }
190:
191: void CListWnd::OnMDIActivate(BOOL bActivate, CWnd * pActive,
192: CWnd* pDeactivate)
193: {
194: CMDIFrameWnd * pFrame = m_pMDIFrameWnd;
195: CMenu * pWinPopupMenu = NULL;
196: CMenu * pMenu = NULL;
197:
198: m_bWindowActive = bActivate;
199:
200: if (bActivate) {
201: pMenu = new CMenu;
202: pMenu->LoadMenu("MdiMenuList");
203: pWinPopupMenu = pMenu->GetSubMenu(LISTWIN_MENU_POSITION);
204:
205: CMenu * pLastMenu = pFrame->MDISetMenu(pMenu,pWinPopupMenu);
206: pLastMenu->DestroyMenu();
207:
208: delete m_pMenuCurrent;
209: m_pMenuCurrent = pMenu;
210: } else {
211: pMenu = new CMenu;
212: pMenu->LoadMenu("MdiMenuInit");
213: pWinPopupMenu = pMenu->GetSubMenu(INIT_MENU_POS);
214:
215: CMenu * pLastMenu = pFrame->MDISetMenu(pMenu, pWinPopupMenu);
216: pLastMenu->DestroyMenu();
217:
218: delete m_pMenuCurrent;
219: m_pMenuCurrent = pMenu;
220: }
221:
222: pFrame->DrawMenuBar();
223: }
224:
225: void CListWnd::OnPaint()
226: {
227: CPaintDC dc (this);
228: CRect rt;
229: CBrush b(RGB(0, 0, 0));
230:
231: dc.FillRect(&dc.m_ps.rcPaint, &b);
232:
233: return;
234: }
235:
236: void CListWnd::OnVScroll(UINT wParam, UINT pos, CScrollBar * p)
237: {
238: pLeft->OnVScroll(wParam, pos, p);
239: m_nVscrollPos = pRight->OnVScroll(wParam, pos, p);
240: SetScrollPos( SB_VERT, m_nVscrollPos );
241:
242: return;
243: }
244:
245: void CListWnd::OnUp()
246: {
247: InvalidateLine();
248:
249: if ( m_nSelectLine <= 0 ) {
250: m_nSelectLine = m_ListHead.GetCount() - 1;
251: m_nVscrollPos = max( 0, m_nSelectLine + 1 - ( m_cyClient / m_cyChar ) );
252: Invalidate( TRUE );
253: } else {
254: m_nSelectLine -= 1;
255: if (m_nSelectLine - m_nVscrollPos < 0) {
256: OnVScroll( SB_LINEUP, 0, NULL );
257: }
258:
259: if (m_nSelectLine - m_nVscrollPos > (m_cyClient / m_cyChar ) ) {
260: m_nVscrollPos = m_nSelectLine + 1 - (m_cyClient / m_cyChar);
261: SetScrollPos( SB_VERT, m_nVscrollPos, TRUE );
262: Invalidate( TRUE );
263: }
264: if (m_nSelectLine - m_nVscrollPos < 0) {
265: m_nVscrollPos = m_nSelectLine;
266: SetScrollPos( SB_VERT, m_nVscrollPos, TRUE );
267: Invalidate( TRUE );
268: }
269: }
270:
271: InvalidateLine();
272: }
273:
274: void CListWnd::OnDown()
275: {
276:
277: InvalidateLine();
278:
279: if (( m_nSelectLine == (int)(m_ListHead.GetCount() - 1 )) ||
280: (m_nSelectLine == -1)) {
281: m_nSelectLine = 0;
282: m_nVscrollPos = 0;
283: Invalidate( TRUE );
284: } else {
285: m_nSelectLine += 1;
286: if ((m_nSelectLine - m_nVscrollPos + 1) > (m_cyClient/m_cyChar)) {
287: OnVScroll( SB_LINEDOWN, 0, NULL );
288: }
289:
290: if (m_nSelectLine - m_nVscrollPos > (m_cyClient / m_cyChar ) ) {
291: m_nVscrollPos = m_nSelectLine + 1 - (m_cyClient / m_cyChar);
292: SetScrollPos( SB_VERT, m_nVscrollPos, TRUE );
293: Invalidate( TRUE );
294: }
295: if (m_nSelectLine - m_nVscrollPos < 0) {
296: m_nVscrollPos = m_nSelectLine;
297: SetScrollPos( SB_VERT, m_nVscrollPos, TRUE );
298: Invalidate( TRUE );
299: }
300: }
301:
302: InvalidateLine();
303: }
304:
305: void CListWnd::OnKeyDown( UINT wParam, UINT, UINT )
306: {
307: switch( wParam ) {
308: case VK_HOME:
309: OnVScroll( SB_TOP, 0, NULL );
310: break;
311: case VK_END:
312: OnVScroll( SB_BOTTOM, 0, NULL );
313: break;
314:
315: case VK_PRIOR:
316: OnVScroll( SB_PAGEUP, 0, NULL );
317: break;
318:
319: case VK_NEXT:
320: OnVScroll( SB_PAGEDOWN, 0, NULL );
321: break;
322:
323: case VK_LEFT:
324: OnHScroll( SB_PAGEUP, 0, NULL );
325: break;
326:
327: case VK_RIGHT:
328: OnHScroll( SB_PAGEDOWN, 0, NULL );
329: break;
330: }
331: }
332:
333: void CListWnd::OnLButtonDblClk( UINT wParam, CPoint location )
334: {
335: #if 0
336: if (m_nSelectLine == -1) {
337: OnLButtonDown( wParam, location );
338: }
339: OnEdit();
340: #endif
341: }
342:
343:
344:
345: afx_msg void CListWnd::OnSortAlpha()
346: {
347: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_UNCHECKED);
348: m_SortOrder = LIST_ALPHA;
349: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_CHECKED);
350: Invalidate(TRUE);
351: return;
352: } /* CListWnd::OnSortAlpha() */
353:
354: afx_msg void CListWnd::OnSortCalls()
355: {
356: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_UNCHECKED);
357: m_SortOrder = LIST_CALLS;
358: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_CHECKED);
359: Invalidate(TRUE);
360: return;
361: } /* CListWnd::OnSortCalls() */
362:
363: afx_msg void CListWnd::OnSortTime()
364: {
365: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_UNCHECKED);
366: m_SortOrder = fChildren ? LIST_TIME_TOTAL : LIST_TIME;
367: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_CHECKED);
368: Invalidate(TRUE);
369: return;
370: } /* CListWnd::OnSortTime() */
371:
372: afx_msg void CListWnd::OnSortTimePer()
373: {
374: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_UNCHECKED);
375: m_SortOrder = fChildren ? LIST_PER_TIME_TOTAL : LIST_PER_TIME;
376: m_pMenuCurrent->CheckMenuItem(IDM_LIST + (m_SortOrder & 7), MF_BYCOMMAND | MF_CHECKED);
377: Invalidate(TRUE);
378: return;
379: } /* CListWnd::OnSortTimePer() */
380:
381: void CListWnd::OnRanges()
382: {
383: CFont cFont;
384: CFont * lpcFont;
385:
386: DoRangesDlg(this, &rs);
387:
388: CClientDC cdc( this );
389:
390: cFont.CreateFontIndirect(&logFont);
391: lpcFont = cdc.SelectObject(&cFont);
392: // pTimerObj->AssignSizes( &cdc, fZoom, 0, &rs);
393: // SetRect( pTimerObj->AssignLocations()) ;
394: cdc.SelectObject(lpcFont);
395:
396: Invalidate(TRUE);
397:
398: return;
399: } /* CListWnd::OnRanges() */
400:
401: void CListWnd::OnFont()
402: {
403: CFontDialog fontDlg(&logFont);
404:
405: if (fontDlg.DoModal()) {
406:
407: pRight->ComputeWidths();
408: pLeft->ComputeWidths();
409: }
410: return;
411: } /* CListWnd::OnFont() */
412:
413: afx_msg void CListWnd::OnLButtonDown(UINT nFlags, CPoint pt)
414: {
415: CClientDC dc(this);
416:
417: fCapture = TRUE;
418: SetCapture();
419: rtCapture.SetRect(pt.x-1, 0, pt.x+1, m_cyClient);
420: dc.InvertRect(&rtCapture);
421: return;
422: } /* CListWnd::OnLButtonDown() */
423:
424: afx_msg void CListWnd::OnLButtonUp(UINT nFlags, CPoint pt)
425: {
426: int x;
427:
428: if (fCapture) {
429: ReleaseCapture();
430: fCapture = FALSE;
431: x = min(max(pt.x, 10), m_cxClient-10);
432: ratio = ((float) x) / (float)m_cxClient;
433:
434: pLeft->MoveWindow(0, 0, x-1, m_cyClient);
435: pRight->MoveWindow(x+2, 0, m_cxClient-(x+2), m_cyClient);
436: } else {
437: CWnd::OnLButtonUp(nFlags, pt);
438: }
439: } /* CListWnd::OnLButtonDown() */
440:
441: afx_msg void CListWnd::OnMouseMove(UINT nFlags, CPoint pt)
442: {
443: if (!fCapture) {
444:
445: SetCursor(HCursorSizer);
446:
447: } else {
448: CClientDC dc(this);
449: int x = min(max(pt.x, 10), m_cxClient-10);
450:
451: dc.InvertRect(&rtCapture);
452: rtCapture.SetRect(x-1, 0, x+1, m_cyClient);
453: dc.InvertRect(&rtCapture);
454: }
455: } /* CListWnd::OnMouseMove() */
456:
457: afx_msg void CListWnd::OnChildren()
458: {
459: fChildren = !fChildren;
460: if (m_SortOrder == LIST_TIME) {
461: m_SortOrder = LIST_TIME_TOTAL;
462: } else if (m_SortOrder == LIST_TIME_TOTAL) {
463: m_SortOrder = LIST_TIME;
464: } else if (m_SortOrder == LIST_PER_TIME) {
465: m_SortOrder = LIST_PER_TIME_TOTAL;
466: } else if (m_SortOrder == LIST_PER_TIME_TOTAL) {
467: m_SortOrder = LIST_PER_TIME;
468: }
469: m_pMenuCurrent->CheckMenuItem(IDM_LIST_CHILDREN, MF_BYCOMMAND | (fChildren ? MF_CHECKED : MF_UNCHECKED));
470: Invalidate(TRUE);
471: return;
472: } /* CListWnd::OnChildren() */
473:
474:
475:
476:
477: /**********************************************************************/
478:
479: BOOL CListWndChild::Create(DWORD style, const RECT& rect, CListWnd * parent)
480: {
481: const char * pszStockClass;
482:
483: pszStockClass = AfxRegisterWndClass( CS_HREDRAW | CS_VREDRAW, NULL,
484: (HBRUSH) (COLOR_WINDOW+1), NULL);
485:
486: pListWnd = parent;
487:
488: return CWnd::Create(pszStockClass, "A", style, rect, parent, 999);
489:
490:
491: } /* CListWndChild::Create() */
492:
493: int CListWndChild::OnCreate(LPCREATESTRUCT p)
494: {
495: // ComputeWidths();
496:
497: return 0;
498: } /* CListWndChild::OnCreate() */
499:
500: void CListWndChild::OnDestroy()
501: {
502: return;
503: } /* CListWndCHild::OnDestroy() */
504:
505:
506: void CListWndChild::OnSize(UINT nType, int cx, int cy)
507: {
508: m_cxClient = cx;
509: m_cyClient = cy;
510:
511: SetScrollRange(SB_HORZ, 0, max(1, m_nHscrollMax - cx), TRUE);
512:
513: m_nVscrollMax = max(1, (int)(ListHead()->GetCount())-m_cyClient/m_cyChar);
514:
515: CWnd::OnSize(nType, cx, cy);
516:
517: return;
518: } /* CListWndChild::OnSize() */
519:
520: void CListWndChild::OnHScroll(UINT wParam, UINT pos, CScrollBar *)
521: {
522: int nScrollInc;
523:
524: switch( wParam ) {
525: case SB_LEFT:
526: nScrollInc = -m_nVscrollPos;
527: break;
528:
529: case SB_RIGHT:
530: nScrollInc = m_cxClient;
531: break;
532:
533: case SB_LINELEFT:
534: nScrollInc = -1;
535: break;
536:
537: case SB_LINERIGHT:
538: nScrollInc = 1;
539: break;
540:
541: case SB_PAGELEFT:
542: nScrollInc = -m_cxClient;
543: break;
544:
545: case SB_PAGERIGHT:
546: nScrollInc = m_cxClient;
547: break;
548:
549: case SB_THUMBTRACK:
550: nScrollInc = pos - m_nHscrollPos;
551: break;
552:
553: default:
554: nScrollInc = 0;
555: }
556:
557: nScrollInc = max( -m_nHscrollPos,
558: min(nScrollInc,
559: (m_nHscrollMax - m_cxClient) - m_nHscrollPos ));
560: if (nScrollInc) {
561: m_nHscrollPos += nScrollInc;
562: SetScrollPos( SB_HORZ, m_nHscrollPos );
563: ScrollWindow( -nScrollInc, 0);
564: UpdateWindow();
565: }
566: return;
567: } /* CListWndChild::OnHScroll() */
568:
569: int CListWndChild::OnVScroll(UINT wParam, UINT pos, CScrollBar *)
570: {
571: int nScrollInc;
572:
573: switch( wParam ) {
574: case SB_TOP:
575: nScrollInc = -m_nVscrollPos;
576: break;
577:
578: case SB_BOTTOM:
579: nScrollInc = m_nVscrollMax;
580: break;
581:
582: case SB_LINEUP:
583: nScrollInc = -1;
584: break;
585:
586: case SB_LINEDOWN:
587: nScrollInc = 1;
588: break;
589:
590: case SB_PAGEUP:
591: nScrollInc = min( -1, -(m_cyClient/m_cyChar - 2));
592: break;
593:
594: case SB_PAGEDOWN:
595: nScrollInc = max( 1, m_cyClient/m_cyChar - 2);
596: break;
597:
598: case SB_THUMBTRACK:
599: nScrollInc = pos - m_nVscrollPos;
600: break;
601:
602: default:
603: nScrollInc = 0;
604: break;
605: }
606:
607: nScrollInc = max( -m_nVscrollPos,
608: min( nScrollInc, m_nVscrollMax - m_nVscrollPos ) );
609:
610: if (nScrollInc) {
611: CRect rt(0, 2*m_cyChar+1, m_cxClient, m_cyClient);
612: m_nVscrollPos += nScrollInc;
613: ScrollWindow( 0, -m_cyChar * nScrollInc, NULL, &rt );
614: UpdateWindow();
615: }
616:
617: return m_nVscrollPos;
618: } /* CListWndChild::OnVScroll() */
619:
620:
621: afx_msg void CListWndChild::OnMouseMove(UINT nFlags, CPoint pt)
622: {
623: SetCursor(HCursorNormal);
624:
625: return;
626: } /* CListWndChild::OnMouseMove() */
627:
628:
629: /*********************************************************************/
630:
631: BEGIN_MESSAGE_MAP(CListWndLeft, CWnd)
632: ON_WM_CREATE()
633: ON_WM_DESTROY()
634: ON_WM_HSCROLL()
635: ON_WM_MOUSEMOVE()
636: ON_WM_PAINT()
637: ON_WM_SIZE()
638: END_MESSAGE_MAP()
639:
640:
641: void CListWndLeft::OnPaint()
642: {
643: CPaintDC dc(this);
644: CBrush b(RGB(255, 255, 255));
645:
646: CRect area(0, 0, m_cxClient, m_cyClient);
647:
648: int nStart;
649: int nEnd;
650:
651: nStart = max(dc.m_ps.rcPaint.top, 2*m_cyChar);
652: nStart = m_nVscrollPos + (nStart / m_cyChar) - 2;
653:
654: nEnd = min( ListHead()->GetCount(),
655: (dc.m_ps.rcPaint.bottom - dc.m_ps.rcPaint.top) / m_cyChar +
656: nStart + 2);
657:
658: int x = -m_nHscrollPos;
659: int y;
660: int perCent;
661: int j;
662: CRect rt;
663:
664: dc.FillRect( area, &b);
665:
666: dc.SetTextAlign( TA_CENTER | TA_TOP );
667: rt.SetRect(0, 0, m_cxClient, m_cyChar);
668: dc.ExtTextOut((m_cxClient-5)/2, 0, ETO_CLIPPED, &rt, "Name", 4, NULL);
669:
670: dc.SetTextAlign( TA_LEFT | TA_TOP );
671: dc.SetBkMode(TRANSPARENT);
672:
673: /*
674: * Print out the data
675: */
676:
677: CString szDisplay;
678: ListItem * pCur;
679:
680: for (y= (nStart - m_nVscrollPos + 2) * m_cyChar;
681: nStart < nEnd; nStart++, y += m_cyChar ) {
682: pCur = ListHead()->GetPosition( nStart, SortOrder());
683: perCent = (int) pCur->Time().PerCent(ListHead()->TotalTime());
684:
685: for (j=0; j<RangeStruct()->cRanges-1; j++) {
686: if ((RangeStruct()->Above[j] <= perCent) &&
687: (perCent < RangeStruct()->Above[j+1])) {
688: break;
689: }
690: }
691:
692: CBrush bBack( RangeStruct()->BackColor[j] );
693:
694: dc.SetTextColor( RangeStruct()->TextColor[j] * RGB(255, 255, 255));
695:
696: area.top = y;
697: area.bottom = y + m_cyChar;
698: dc.FillRect( area, &bBack );
699:
700: /*
701: * Print out the dll and function name
702: */
703:
704: szDisplay = pCur->strModule() + " : " + pCur->strFunction();
705:
706: dc.TextOut(x, y, szDisplay);
707:
708: }
709:
710: dc.MoveTo(0, 2*m_cyChar-1); dc.LineTo(m_cxClient, 2*m_cyChar-1);
711: dc.MoveTo(0, 2*m_cyChar); dc.LineTo(m_cxClient, 2*m_cyChar);
712:
713: return;
714: } /* CListWndLeft::OnPaint() */
715:
716:
717: void CListWndLeft::ComputeWidths()
718: {
719: int i;
720: CRect rt;
721: CString str;
722: CClientDC cdc( this );
723: CFont cFont;
724: CFont * lpcFont;
725: TEXTMETRIC tm;
726: int maxWidth = 0;
727:
728: cFont.CreateFontIndirect(LogFont());
729: lpcFont = cdc.SelectObject(&cFont);
730: cdc.GetTextMetrics( &tm );
731:
732: m_cxChar = tm.tmAveCharWidth;
733: m_cyChar = tm.tmHeight + tm.tmExternalLeading;
734: m_nVscrollPos = m_nHscrollPos = 0;
735:
736: ListItem * pCur;
737:
738: for (i=0; i<ListHead()->GetCount(); i++) {
739: pCur = ListHead()->GetPosition(i, SortOrder());
740: str = pCur->strModule() + " : " + pCur->strFunction();
741:
742: rt.SetRectEmpty();
743: cdc.DrawText(str, -1, &rt, DT_CALCRECT);
744: maxWidth = max(maxWidth, rt.Width()+10);
745: }
746:
747: m_nHscrollMax = maxWidth;
748: SetScrollRange(SB_HORZ, 0, max(1, m_nHscrollMax - m_cxClient), TRUE);
749:
750: m_nVscrollMax = max(1, (int)(ListHead()->GetCount())-m_cyClient/m_cyChar);
751:
752: cdc.SelectObject(lpcFont);
753: Invalidate(TRUE);
754:
755: return;
756: } /* CListWndLeft::ComputeWidths() */
757:
758: /*********************************************************************/
759:
760: BEGIN_MESSAGE_MAP(CListWndRight, CWnd)
761: ON_WM_CREATE()
762: ON_WM_DESTROY()
763: ON_WM_HSCROLL()
764: ON_WM_MOUSEMOVE()
765: ON_WM_PAINT()
766: ON_WM_SIZE()
767: END_MESSAGE_MAP()
768:
769:
770: void CListWndRight::OnPaint()
771: {
772: CPaintDC dc(this);
773: CBrush b(RGB(255, 255, 255));
774: CFont cFont;
775: CFont * lpcFont;
776:
777: CRect area(0, 0, m_cxClient, m_cyClient);
778:
779: dc.FillRect( area, &b);
780:
781: CRect rt;
782: char rgch[256];
783: int perCent;
784: int perCentPer;
785: int perCentAll;
786: int perCentPerAll;
787: int j;
788: int i;
789: int x = -m_nHscrollPos;
790: int y;
791:
792: int nStart;
793: int nEnd;
794:
795: nStart = max(dc.m_ps.rcPaint.top, 2*m_cyChar);
796: nStart = m_nVscrollPos + (nStart / m_cyChar) - 2;
797:
798: nEnd = min( ListHead()->GetCount(),
799: (dc.m_ps.rcPaint.bottom - dc.m_ps.rcPaint.top) / m_cyChar +
800: nStart + 2);
801:
802: dc.FillRect(&dc.m_ps.rcPaint, &b);
803:
804: area.SetRect(0, 0, m_cxClient, 0);
805: dc.SetBkMode(TRANSPARENT);
806:
807: cFont.CreateFontIndirect(LogFont());
808: lpcFont = dc.SelectObject(&cFont);
809:
810: area.bottom = 2*m_cyChar;
811: dc.FillRect( area, &b );
812: dc.SetTextColor(0);
813:
814: /*
815: * Print out the titles for the List Window
816: */
817:
818: dc.SetTextAlign( TA_CENTER | TA_TOP );
819:
820: rt.SetRect(x, 0, x+rgl[0]-5, 2*m_cyChar);
821: dc.ExtTextOut(x+(rgl[0]-5)/2, 0, ETO_CLIPPED, &rt, "Num", 3, NULL);
822: dc.ExtTextOut(x+(rgl[0]-5)/2, m_cyChar, ETO_CLIPPED, &rt, "Calls", 5, NULL);
823:
824: rt.SetRect(x+rgl[0], 0, x+rgl[4]-5, 2*m_cyChar);
825: dc.ExtTextOut(x+(rgl[0]+rgl[4]-5)/2, 0, ETO_CLIPPED, &rt, "Function Only", 13, NULL);
826:
827: rt.SetRect(x+rgl[0], 0, x+rgl[2]-5, 2*m_cyChar);
828: dc.ExtTextOut(x+(rgl[0]+rgl[2]-5)/2, m_cyChar, ETO_CLIPPED, &rt, "Function", 8, NULL);
829:
830: rt.SetRect(x+rgl[2], 0, x+rgl[4]-5, 2*m_cyChar);
831: dc.ExtTextOut(x+(rgl[2]+rgl[4]-5)/2, m_cyChar, ETO_CLIPPED, &rt, "Per Call", 8, NULL);
832:
833: rt.SetRect(x+rgl[4], 0, x+rgl[6]-5, 2*m_cyChar);
834: dc.ExtTextOut(x+(rgl[4]+rgl[6]-5)/2, m_cyChar, ETO_CLIPPED, &rt, "Function", 8, NULL);
835:
836: rt.SetRect(x+rgl[4], 0, x+rgl[8], 2*m_cyChar);
837: dc.ExtTextOut(x+(rgl[4]+rgl[8])/2, 0, ETO_CLIPPED, &rt, "Function + Children", 19, NULL);
838:
839: rt.SetRect(x+rgl[6], 0, x+rgl[8], 2*m_cyChar);
840: dc.ExtTextOut(x+(rgl[6]+rgl[8])/2, m_cyChar, ETO_CLIPPED, &rt, "Per Call", 8, NULL);
841:
842: dc.SetTextAlign( TA_RIGHT | TA_TOP );
843:
844:
845: /*
846: * Now print out the actual data items
847: */
848:
849: CString szDisplay;
850: ListItem * pCur;
851:
852: for ( y= (nStart - m_nVscrollPos + 2)*m_cyChar;
853: nStart < nEnd;
854: nStart++, y += m_cyChar ) {
855: pCur = ListHead()->GetPosition( nStart, SortOrder() );
856: perCent = (int) pCur->Time().PerCent(ListHead()->TotalTime());
857: perCentPer = (int) pCur->TimePerCall().PerCent(ListHead()->TotalTime());
858: perCentAll = (int) pCur->TimeAll().PerCent(ListHead()->TotalTime());
859: perCentPerAll = (int) pCur->TimeAllPerCall().PerCent(ListHead()->TotalTime());
860:
861: for (j=0; j<RangeStruct()->cRanges-1; j++) {
862: if ((RangeStruct()->Above[j] <= perCent) &&
863: (perCent < RangeStruct()->Above[j+1])) {
864: break;
865: }
866: }
867:
868: CBrush bBack( RangeStruct()->BackColor[j] );
869:
870: dc.SetTextColor( RangeStruct()->TextColor[j] * RGB(255, 255, 255));
871:
872: area.top = y;
873: area.bottom = y + m_cyChar;
874: dc.FillRect( area, &bBack );
875:
876: /*
877: * Now print the number of calls
878: */
879:
880: sprintf(rgch, "%d", pCur->Calls());
881: rt.SetRect(x, y, x+x+rgl[0]-5, y+m_cyChar);
882: dc.ExtTextOut(x+rgl[0]-5, y, ETO_CLIPPED, &rt,
883: rgch, strlen(rgch), NULL);
884:
885: /*
886: *
887: */
888:
889: pCur->Time().format(rgch);
890: rt.SetRect(x+rgl[0], y, x+rgl[1]-5, y+m_cyChar);
891: dc.ExtTextOut(x+rgl[1]-5, y, ETO_CLIPPED, &rt,
892: rgch, strlen(rgch), NULL);
893:
894: sprintf(rgch, "%d%%", perCent);
895: rt.SetRect(x+rgl[1], y, x+rgl[2]-5, y+m_cyChar);
896: dc.ExtTextOut(x+rgl[2]-5, y, ETO_CLIPPED, &rt,
897: rgch, strlen(rgch), NULL);
898:
899: pCur->TimePerCall().format(rgch);
900: rt.SetRect(x+rgl[2], y, x+rgl[3]-5, y+m_cyChar);
901: dc.ExtTextOut(x+rgl[3]-5, y, ETO_CLIPPED, &rt,
902: rgch, strlen(rgch), NULL);
903:
904: sprintf(rgch, "%d%%", perCentPer);
905: rt.SetRect(x+rgl[3], y, x+rgl[4]-5, y+m_cyChar);
906: dc.ExtTextOut(x+rgl[4]-5, y, ETO_CLIPPED, &rt,
907: rgch, strlen(rgch), NULL);
908:
909: pCur->TimeAll().format(rgch);
910: rt.SetRect(x+rgl[4], y, x+rgl[5]-5, y+m_cyChar);
911: dc.ExtTextOut(x+rgl[5]-5, y, ETO_CLIPPED, &rt,
912: rgch, strlen(rgch), NULL);
913:
914: sprintf(rgch, "%d%%", perCentAll);
915: rt.SetRect(x+rgl[5], y, x+rgl[6]-5, y+m_cyChar);
916: dc.ExtTextOut(x+rgl[6]-5, y, ETO_CLIPPED, &rt,
917: rgch, strlen(rgch), NULL);
918:
919: pCur->TimeAllPerCall().format(rgch);
920: rt.SetRect(x+rgl[6], y, x+rgl[7]-5, y+m_cyChar);
921: dc.ExtTextOut(x+rgl[7]-5, y, ETO_CLIPPED, &rt,
922: rgch, strlen(rgch), NULL);
923:
924: sprintf(rgch, "%d%%", perCentPerAll);
925: rt.SetRect(x+rgl[7], y, x+rgl[8]-5, y+m_cyChar);
926: dc.ExtTextOut(x+rgl[8]-5, y, ETO_CLIPPED, &rt,
927: rgch, strlen(rgch), NULL);
928: }
929:
930: /*
931: * Now lets draw in the funny lines which make things look better
932: */
933:
934: for (i=0; i<8; i++) {
935: if ((i == 1) || (i == 3) || (i == 5) || (i == 7)) {
936: y = 2*m_cyChar;
937: } else if ((i == 2) || (i == 6)) {
938: y = m_cyChar;
939: } else {
940: y = 0;
941: }
942: dc.MoveTo(x+rgl[i]-3, y); dc.LineTo(x+rgl[i]-3, m_cyClient);
943: dc.MoveTo(x+rgl[i]-2, y); dc.LineTo(x+rgl[i]-2, m_cyClient);
944: dc.MoveTo(x+rgl[i]-1, y); dc.LineTo(x+rgl[i]-1, m_cyClient);
945: }
946:
947: dc.MoveTo(x+rgl[0], m_cyChar-1); dc.LineTo(m_cxClient, m_cyChar-1);
948: dc.MoveTo(x+rgl[0], m_cyChar); dc.LineTo(m_cxClient, m_cyChar);
949: dc.MoveTo(x+rgl[0], m_cyChar+1); dc.LineTo(m_cxClient, m_cyChar+1);
950:
951: dc.MoveTo(0, 2*m_cyChar-1); dc.LineTo(m_cxClient, 2*m_cyChar-1);
952: dc.MoveTo(0, 2*m_cyChar); dc.LineTo(m_cxClient, 2*m_cyChar);
953:
954: dc.SelectObject(lpcFont);
955: return;
956: } /* CListWndRight::OnPaint() */
957:
958: void CListWndRight::ComputeWidths()
959: {
960: int i;
961: char rgch[100];
962: CRect rt;
963: CClientDC cdc( this );
964: CFont cFont;
965: CFont * lpcFont;
966: TEXTMETRIC tm;
967:
968: int perCent;
969: int perCentPer;
970: int perCentAll;
971: int perCentPerAll;
972:
973: cFont.CreateFontIndirect(LogFont());
974: lpcFont = cdc.SelectObject(&cFont);
975: cdc.GetTextMetrics( &tm );
976:
977: m_cxChar = tm.tmAveCharWidth;
978: m_cyChar = tm.tmHeight + tm.tmExternalLeading;
979: m_nVscrollPos = m_nHscrollPos = 0;
980:
981: ListItem * pCur;
982: CString szDisplay;
983:
984: for (i=0; i<9; i++) {
985: rgl[i] = 0;
986: }
987:
988:
989: for (i=0; i<ListHead()->GetCount(); i++) {
990: pCur = ListHead()->GetPosition(i, SortOrder());
991:
992: perCent = (int) pCur->Time().PerCent(ListHead()->TotalTime());
993: perCentPer = (int) pCur->TimePerCall().PerCent(ListHead()->TotalTime());
994: perCentAll = (int) pCur->TimeAll().PerCent(ListHead()->TotalTime());
995: perCentPerAll = (int) pCur->TimeAllPerCall().PerCent(ListHead()->TotalTime());
996:
997:
998: /*
999: * Width of # calls
1000: */
1001:
1002: sprintf(rgch, "%d", pCur->Calls());
1003: rt.SetRectEmpty();
1004: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1005: rgl[0] = max(rgl[0], rt.Width()+10);
1006:
1007: /*
1008: *
1009: */
1010:
1011: pCur->Time().format(rgch);
1012: rt.SetRectEmpty();
1013: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1014: rgl[1] = max(rgl[1], rt.Width()+10);
1015:
1016: sprintf(rgch, "%d%%", perCent);
1017: rt.SetRectEmpty();
1018: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1019: rgl[2] = max(rgl[2], rt.Width()+10);
1020:
1021: pCur->TimePerCall().format(rgch);
1022: rt.SetRectEmpty();
1023: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1024: rgl[3] = max(rgl[3], rt.Width()+10);
1025:
1026: sprintf(rgch, "%d%%", perCentPer);
1027: rt.SetRectEmpty();
1028: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1029: rgl[4] = max(rgl[4], rt.Width()+10);
1030:
1031: pCur->TimeAll().format(rgch);
1032: rt.SetRectEmpty();
1033: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1034: rgl[5] = max(rgl[5], rt.Width()+10);
1035:
1036: sprintf(rgch, "%d%%", perCentAll);
1037: rt.SetRectEmpty();
1038: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1039: rgl[6] = max(rgl[6], rt.Width()+10);
1040:
1041: pCur->TimeAllPerCall().format(rgch);
1042: rt.SetRectEmpty();
1043: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1044: rgl[7] = max(rgl[7], rt.Width()+10);
1045:
1046: sprintf(rgch, "%d%%", perCentPerAll);
1047: rt.SetRectEmpty();
1048: cdc.DrawText(rgch, -1, &rt, DT_CALCRECT);
1049: rgl[8] = max(rgl[8], rt.Width()+10);
1050: }
1051:
1052: for (i=1; i<9; i++) {
1053: rgl[i] += rgl[i-1];
1054: }
1055:
1056: m_nHscrollMax = rgl[8];
1057: SetScrollRange(SB_HORZ, 0, max(1, m_nHscrollMax), TRUE);
1058:
1059: m_nVscrollMax = max(1, (int)(ListHead()->GetCount())-m_cyClient/m_cyChar);
1060:
1061: cdc.SelectObject(lpcFont);
1062: Invalidate(TRUE);
1063:
1064: return;
1065: } /* CListWndRight::ComputeWidths() */
1066:
1067:
1068: #if 0
1069: afx_msg void CListWndRight::OnMouseMove(UINT nFlags, CPoint pt)
1070: {
1071: int i;
1072: BOOL f = FALSE;
1073:
1074: // if (!fCapture) {
1075:
1076: SetCursor(HCursorNormal);
1077:
1078: // } else {
1079: // CClientDC dc(this);
1080: // int x = min(max(pt.x, rgl[iCapture-1]+10),
1081: // rgl[iCapture+1]-10);
1082: //
1083: // dc.InvertRect(&rtCapture);
1084: // rtCapture.SetRect(x-1, 0, x+1, m_cyClient);
1085: // dc.InvertRect(&rtCapture);
1086: // }
1087: } /* CListWndRight::OnMouseMove() */
1088:
1089:
1090: afx_msg void CListWnd::OnLButtonDown(UINT nFlags, CPoint pt)
1091: {
1092: BOOL f = FALSE;
1093: int i;
1094:
1095: for (i=1; i<10; i++) {
1096: if ((rgl[i]-5 < pt.x) && (pt.x < rgl[i])) {
1097: f = TRUE;
1098: break;
1099: }
1100: }
1101:
1102: if (f) {
1103: CClientDC dc(this);
1104: fCapture = TRUE;
1105: iCapture = i;
1106: SetCapture();
1107: rtCapture.SetRect(pt.x-1, 0, pt.x+1, m_cyClient);
1108: dc.InvertRect(&rtCapture);
1109: } else {
1110: CWnd::OnLButtonDown(nFlags, pt);
1111: }
1112: } /* CListWnd::OnLButtonDown() */
1113:
1114: afx_msg void CListWnd::OnLButtonUp(UINT nFlags, CPoint pt)
1115: {
1116: if (fCapture) {
1117: ReleaseCapture();
1118: fCapture = FALSE;
1119: rgl[iCapture] = min(max(pt.x, rgl[iCapture-1]+10), rgl[iCapture+1]-10);
1120: Invalidate(TRUE);
1121: } else {
1122: CWnd::OnLButtonUp(nFlags, pt);
1123: }
1124: } /* CListWnd::OnLButtonDown() */
1125: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.