Return to listwin.cpp CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview

Annotation of mstools/samples/sdktools/capview/listwin.cpp, revision 1.1

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.