Return to tree.cpp CVS log

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

Annotation of mstools/samples/sdktools/capview/tree.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        "dialogs.h"
        !             8: #include        "resource.h"
        !             9: #include        "ranges.h"
        !            10: #include        "dispobj.h"
        !            11: #include        "timer.h"
        !            12: #include        "tree.h"
        !            13: 
        !            14: 
        !            15: #define PAGESIZE 8
        !            16: 
        !            17: /*********************** GLOBAL DATA *****************************/
        !            18: 
        !            19: CAaaArray       rgLoc;
        !            20: BOOL  fXYZ = FALSE;
        !            21: BOOL  fTotal = TRUE;
        !            22: extern  HICON   HIconTree;
        !            23: 
        !            24: /*****************************************************************/
        !            25: 
        !            26: BEGIN_MESSAGE_MAP(CTREEWND, CMDIChildWnd)
        !            27:        ON_WM_CREATE()
        !            28:        ON_WM_DESTROY()
        !            29:        ON_WM_MDIACTIVATE()
        !            30:        ON_WM_HSCROLL()
        !            31:        ON_WM_KEYDOWN()
        !            32:        ON_WM_LBUTTONDBLCLK()
        !            33:        ON_WM_LBUTTONDOWN()
        !            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_TREE_EXPANDALL, OnExpandAll )
        !            41:        ON_COMMAND( IDM_TREE_FONT, OnFont )
        !            42:        ON_COMMAND( IDM_TREE_TOTAL, OnTotal )
        !            43:        ON_COMMAND( IDM_TREE_XYZ, OnXYZ )
        !            44:        ON_COMMAND( IDM_TREE_ZOOM, OnZoom )
        !            45:        ON_COMMAND( IDM_TREE_RANGES, OnRanges )
        !            46: 
        !            47: END_MESSAGE_MAP()
        !            48: 
        !            49: BOOL CTREEWND::Create(LPCSTR szTitle, LONG style, const RECT& rect,
        !            50:        CMDIFrameWnd* parent)
        !            51: {
        !            52:     const char * pszStockClass = AfxRegisterWndClass(
        !            53:        CS_HREDRAW | CS_VREDRAW, LoadCursor(NULL, IDC_UPARROW),
        !            54:        (HBRUSH) (COLOR_WINDOW+1), HIconTree);
        !            55: 
        !            56:     return CMDIChildWnd::Create(pszStockClass, szTitle, style, rect, parent);
        !            57: }
        !            58: 
        !            59: 
        !            60: CTREEWND::CTREEWND()  : ptOrigin(0, 0)
        !            61: {
        !            62:    int  i;
        !            63:    
        !            64:    m_pMenuCurrent = NULL;
        !            65:    m_bWindowActive = FALSE;
        !            66:    logFont = DefaultFont;
        !            67:    fZoom = FALSE;
        !            68:    
        !            69:    for (i=0; i<MAX_NUM_RANGES; i++) {
        !            70:        rs.TextColor[i] = 0;
        !            71:        rs.BackColor[i] = RGB( 0, 0, 0);
        !            72:        rs.Above[i] = 101;
        !            73:    }
        !            74:    
        !            75:    rs.Above[0] = 0;  rs.BackColor[0] = RGB(   0,   0, 255);  
        !            76:                rs.TextColor[0] = 1;
        !            77:    rs.Above[1] = 1;  rs.BackColor[1] = RGB(   0, 255,   0);
        !            78:    rs.Above[2] = 2;  rs.BackColor[2] = RGB(   0, 255, 255);
        !            79:    rs.Above[3] = 5;  rs.BackColor[3] = RGB( 255, 255,   0);
        !            80:    rs.Above[4] = 20;  rs.BackColor[4] = RGB( 255,   0,   0);
        !            81:    rs.Above[5] = 101;
        !            82:    rs.cRanges = 5;
        !            83: }
        !            84: 
        !            85: CTREEWND::~CTREEWND()
        !            86: {
        !            87:     if (m_bWindowActive) {
        !            88:        m_pMenuCurrent->Detach();
        !            89:     }
        !            90: }
        !            91: 
        !            92: 
        !            93: int CTREEWND::OnCreate(LPCREATESTRUCT p)
        !            94: {
        !            95:     TEXTMETRIC  tm;
        !            96: 
        !            97:     CDC *       dc = GetDC();
        !            98:     dc->GetTextMetrics( &tm );
        !            99:     ReleaseDC( dc );
        !           100: 
        !           101:     m_cxChar = tm.tmAveCharWidth;
        !           102:     m_cxCaps = ( (tm.tmPitchAndFamily & 1) ? 3 : 2) * m_cxChar / 2;
        !           103:     m_cyChar = tm.tmHeight + tm.tmExternalLeading;
        !           104:     m_nMaxWidth = ( 20 ) * m_cxCaps;
        !           105: 
        !           106:     return 0;
        !           107: }
        !           108: 
        !           109: 
        !           110: void CTREEWND::OnDestroy()
        !           111: {
        !           112:   //  m_pMDIFrameWnd->SendMessage(WM_CHILDDESTROY, (UINT)m_hWnd, 0);
        !           113:     return;
        !           114: }
        !           115: 
        !           116: 
        !           117: void CTREEWND::OnSize(UINT nType, int cx, int cy)
        !           118: {
        !           119:     m_cxClient = cx;
        !           120:     m_cyClient = cy;
        !           121: 
        !           122:     ptOrigin.y = min( ptOrigin.y, rtArea.Height());
        !           123:     
        !           124:     SetScrollRange( SB_VERT, 0, rtArea.Height(), FALSE );
        !           125:     SetScrollPos( SB_VERT, ptOrigin.y, TRUE );
        !           126: 
        !           127: 
        !           128:     ptOrigin.x = min( ptOrigin.x, rtArea.Width() );
        !           129: 
        !           130:     SetScrollRange( SB_HORZ, 0, rtArea.Width(), FALSE );
        !           131:     SetScrollPos( SB_HORZ, ptOrigin.x, TRUE );
        !           132: 
        !           133:     CMDIChildWnd::OnSize(nType, cx, cy);
        !           134: 
        !           135:     return;
        !           136: }
        !           137: 
        !           138: void CTREEWND::OnMDIActivate(BOOL bActivate, CWnd * pActive,
        !           139:        CWnd* pDeactivate)
        !           140: {
        !           141:     CMDIFrameWnd * pFrame = m_pMDIFrameWnd;
        !           142:     CMenu *             pWinPopupMenu = NULL;
        !           143:     CMenu *             pMenu = NULL;
        !           144: 
        !           145:     m_bWindowActive = bActivate;
        !           146: 
        !           147:     if (bActivate) {
        !           148:        pMenu = new CMenu;
        !           149:        pMenu->LoadMenu("MdiMenuTree");
        !           150:        pWinPopupMenu = pMenu->GetSubMenu(TREE_MENU_POSITION);
        !           151: 
        !           152:        CMenu * pLastMenu = pFrame->MDISetMenu(pMenu,pWinPopupMenu);
        !           153:        pLastMenu->DestroyMenu();
        !           154: 
        !           155:        delete m_pMenuCurrent;
        !           156:        m_pMenuCurrent = pMenu;
        !           157:     } else {
        !           158:        pMenu = new CMenu;
        !           159:        pMenu->LoadMenu("MdiMenuInit");
        !           160:        pWinPopupMenu = pMenu->GetSubMenu(INIT_MENU_POS);
        !           161: 
        !           162:        CMenu * pLastMenu = pFrame->MDISetMenu(pMenu, pWinPopupMenu);
        !           163:        pLastMenu->DestroyMenu();
        !           164: 
        !           165:        delete m_pMenuCurrent;
        !           166:        m_pMenuCurrent = pMenu;
        !           167:     }
        !           168: 
        !           169:     pFrame->DrawMenuBar();
        !           170: }
        !           171: 
        !           172: void CTREEWND::OnPaint()
        !           173: {
        !           174:     CPaintDC dc (this);
        !           175:     CFont       cFont;
        !           176:     CFont *     lpcFontOld;
        !           177:     
        !           178:     if (!fZoom) {
        !           179:        cFont.CreateFontIndirect(&logFont);
        !           180:        lpcFontOld = dc.SelectObject(&cFont);
        !           181:     }
        !           182:     dc.SetWindowOrg(ptOrigin);
        !           183:     
        !           184:     dc.SetBkMode(TRANSPARENT);
        !           185:     dc.m_ps.rcPaint.left += ptOrigin.x;
        !           186:     dc.m_ps.rcPaint.right += ptOrigin.x;
        !           187:     dc.m_ps.rcPaint.top += ptOrigin.y;
        !           188:     dc.m_ps.rcPaint.bottom += ptOrigin.y;
        !           189:     
        !           190:     timerRoot.PaintTree(&dc, fZoom, &rs, dc.m_ps.rcPaint);
        !           191: 
        !           192:     if (!fZoom) {
        !           193:        dc.SelectObject(lpcFontOld);    
        !           194:     }
        !           195:     return;
        !           196: }
        !           197: 
        !           198: void CTREEWND::OnVScroll(UINT wParam, UINT pos, CScrollBar *)
        !           199: {
        !           200:     int     nScrollInc;
        !           201: 
        !           202:     switch( wParam ) {
        !           203:     case SB_TOP:
        !           204:        nScrollInc = -ptOrigin.y;
        !           205:        break;
        !           206: 
        !           207:     case SB_BOTTOM:
        !           208:        nScrollInc = rtArea.Height() - ptOrigin.y;
        !           209:        break;
        !           210: 
        !           211:     case SB_LINEUP:
        !           212:        nScrollInc = -m_cyClient/10;
        !           213:        break;
        !           214: 
        !           215:     case SB_LINEDOWN:
        !           216:        nScrollInc = m_cyClient/10;
        !           217:        break;
        !           218: 
        !           219:     case SB_PAGEUP:
        !           220:        nScrollInc = min( -1, -m_cyClient);
        !           221:        break;
        !           222: 
        !           223:     case SB_PAGEDOWN:
        !           224:        nScrollInc = max( 1, m_cyClient );
        !           225:        break;
        !           226: 
        !           227:     case SB_THUMBTRACK:
        !           228:        nScrollInc = pos - ptOrigin.y;
        !           229:        break;
        !           230: 
        !           231:     default:
        !           232:        nScrollInc = 0;
        !           233:        break;
        !           234:     }
        !           235: 
        !           236:     nScrollInc = max( -ptOrigin.y, min( nScrollInc, rtArea.Height() - ptOrigin.y ) );
        !           237:     if (nScrollInc) {
        !           238:        ptOrigin.y += nScrollInc;
        !           239:        ScrollWindow( 0, -nScrollInc );
        !           240:        SetScrollPos( SB_VERT, ptOrigin.y );
        !           241:        UpdateWindow();
        !           242:     }
        !           243: }
        !           244: 
        !           245: void CTREEWND::OnHScroll(UINT wParam, UINT pos, CScrollBar *)
        !           246: {
        !           247:     int     nScrollInc;
        !           248: 
        !           249:     switch( wParam ) {
        !           250:     case SB_LINEUP:
        !           251:        nScrollInc = -m_cxClient/10;
        !           252:        break;
        !           253: 
        !           254:     case SB_LINEDOWN:
        !           255:        nScrollInc = m_cxClient/10;
        !           256:        break;
        !           257: 
        !           258:     case SB_PAGEUP:
        !           259:        nScrollInc = -m_cxClient;
        !           260:        break;
        !           261: 
        !           262:     case SB_PAGEDOWN:
        !           263:        nScrollInc = m_cxClient;
        !           264:        break;
        !           265: 
        !           266:     case SB_THUMBTRACK:
        !           267:        nScrollInc = pos - ptOrigin.x;
        !           268:        break;
        !           269: 
        !           270:     default:
        !           271:        nScrollInc = 0;
        !           272:        break;
        !           273:     }
        !           274: 
        !           275:     nScrollInc = max( -ptOrigin.x, min( nScrollInc, rtArea.Width() - ptOrigin.x ) );
        !           276:     if (nScrollInc) {
        !           277:        ptOrigin.x += nScrollInc;
        !           278:        ScrollWindow( -nScrollInc, 0 );
        !           279:        SetScrollPos( SB_HORZ, ptOrigin.x );
        !           280:        UpdateWindow();
        !           281:     }
        !           282: }
        !           283: 
        !           284: void CTREEWND::OnUp()
        !           285: {
        !           286: }
        !           287: 
        !           288: void CTREEWND::OnDown()
        !           289: {
        !           290: }
        !           291: 
        !           292: void CTREEWND::OnKeyDown( UINT wParam, UINT, UINT )
        !           293: {
        !           294:     switch( wParam ) {
        !           295:     case VK_HOME:
        !           296:        OnVScroll( SB_TOP, 0, NULL );
        !           297:        break;
        !           298:     case VK_END:
        !           299:        OnVScroll( SB_BOTTOM, 0, NULL );
        !           300:        break;
        !           301: 
        !           302:     case VK_PRIOR:
        !           303:        OnVScroll( SB_PAGEUP, 0, NULL );
        !           304:        break;
        !           305: 
        !           306:     case VK_NEXT:
        !           307:        OnVScroll( SB_PAGEDOWN, 0, NULL );
        !           308:        break;
        !           309: 
        !           310:     case VK_LEFT:
        !           311:        OnHScroll( SB_PAGEUP, 0, NULL );
        !           312:        break;
        !           313: 
        !           314:     case VK_RIGHT:
        !           315:        OnHScroll( SB_PAGEDOWN, 0, NULL );
        !           316:        break;
        !           317:     }
        !           318: }
        !           319: 
        !           320: void CTREEWND::OnLButtonDown( UINT, CPoint location )
        !           321: {
        !           322:     location.Offset(ptOrigin);
        !           323:     timerRoot.DblClick( location );
        !           324:     timerRoot.SetProperties(SET_LOCATION, fZoom);
        !           325:     SetRect(timerRoot.RectTotal());
        !           326:     Invalidate();
        !           327:    
        !           328:     return;
        !           329: }
        !           330: 
        !           331: void CTREEWND::OnLButtonDblClk( UINT wParam, CPoint location ) 
        !           332: {
        !           333:    
        !           334:    return;
        !           335: }
        !           336: 
        !           337: void CTREEWND::OnFont()
        !           338: {
        !           339:    CFont        cFont;
        !           340:    CFont *      lpcFont;        
        !           341:    CFontDialog  fontDlg(&logFont);
        !           342:    CRect        rt;
        !           343:    
        !           344:    fontDlg.DoModal();   
        !           345:    
        !           346:    CClientDC cdc( this );
        !           347:    cFont.CreateFontIndirect(&logFont);
        !           348:    lpcFont = cdc.SelectObject(&cFont);
        !           349: 
        !           350:    timerRoot.SetProperties(SET_SIZE|SET_LOCATION, fZoom, NULL, &cdc);
        !           351:    SetRect( timerRoot.RectTotal() );
        !           352: 
        !           353:    cdc.SelectObject(lpcFont);
        !           354:    Invalidate();
        !           355:    return;
        !           356: }
        !           357: 
        !           358: 
        !           359: void CTREEWND::OnExpandAll()
        !           360: {
        !           361:     timerRoot.ExpandAll();
        !           362:     timerRoot.SetProperties(SET_LOCATION, fZoom);
        !           363:     SetRect( timerRoot.RectTotal() );
        !           364:     Invalidate();
        !           365: }
        !           366: 
        !           367: void CTREEWND::OnXYZ()
        !           368: {
        !           369:    fXYZ = !fXYZ;
        !           370:    m_pMenuCurrent->CheckMenuItem(IDM_TREE_XYZ,
        !           371:         MF_BYCOMMAND | (fXYZ ? MF_CHECKED : MF_UNCHECKED));
        !           372:    Invalidate();
        !           373: }
        !           374: 
        !           375: void CTREEWND::OnTotal()
        !           376: {
        !           377:    fTotal = !fTotal;
        !           378:    m_pMenuCurrent->CheckMenuItem(IDM_TREE_TOTAL,
        !           379:         MF_BYCOMMAND | (fTotal ? MF_CHECKED : MF_UNCHECKED));
        !           380:    Invalidate();
        !           381: }
        !           382:    
        !           383: void CTREEWND::OnZoom()
        !           384: {
        !           385:    fZoom = !fZoom;
        !           386: 
        !           387:    CClientDC cdc( this );
        !           388: 
        !           389:    timerRoot.SetProperties(SET_LOCATION, fZoom);
        !           390:    SetRect( timerRoot.RectTotal() );
        !           391: 
        !           392:    Invalidate();
        !           393:    
        !           394:    return;    
        !           395: }
        !           396: 
        !           397: void CTREEWND::OnRanges()
        !           398: {
        !           399:     BOOL f = rs.fPrune;
        !           400: 
        !           401:     DoRangesDlg(this, &rs);
        !           402: 
        !           403:     if (f != rs.fPrune) {
        !           404:        timerRoot.SetProperties(SET_COLORS|SET_LOCATION, fZoom, &rs);
        !           405:     } else {
        !           406:        timerRoot.SetProperties(SET_COLORS, fZoom, &rs);
        !           407:     }
        !           408:     SetRect( timerRoot.RectTotal() );
        !           409: 
        !           410:     Invalidate();
        !           411: 
        !           412:     return;
        !           413: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.