Return to dispobj.h CVS log

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

Annotation of mstools/samples/sdktools/capview/dispobj.h, revision 1.1

1.1     ! root        1: /*
        !             2: *
        !             3: */
        !             4: 
        !             5: #include "array_x.h"
        !             6: 
        !             7: #define spaceVertical 10
        !             8: #define spaceHorizontal 40
        !             9: 
        !            10: extern  CBrush  CbrushBackground;
        !            11: extern  CBrush  CbrushFrame;
        !            12: extern  LOGFONT DefaultFont;
        !            13: 
        !            14: extern CAaaArray  rgLoc;
        !            15: extern BOOL fXYZ;
        !            16: extern BOOL fTotal;
        !            17: 
        !            18: enum {
        !            19:     SET_COLORS=1,
        !            20:     SET_PERCENT=2,
        !            21:     SET_STRING=4,
        !            22:     SET_SIZE=8,
        !            23:     SET_LOCATION=16,
        !            24:     SET_LOCATIONPREP=32
        !            25: };
        !            26: 
        !            27: class DISPOBJ
        !            28: {
        !            29:     DISPOBJ *  pParent;
        !            30:     BOOL       fOpen;
        !            31:     DISPOBJ *  pChild;
        !            32:     DISPOBJ *  pSib;
        !            33:     CRect       rtChildren;
        !            34: 
        !            35:   public:
        !            36:     BOOL       fPrune;
        !            37:     POINT      ptRight;
        !            38:     POINT      ptLeft;
        !            39:     CRect      rtArea;
        !            40:     DISPOBJ *   pRoot;
        !            41:     int                iLevel;
        !            42:     CRect       rtTotal;
        !            43:     
        !            44:     DISPOBJ * Parent() { return pParent; }
        !            45:     DISPOBJ * Child() { return pChild; }
        !            46:     DISPOBJ * Sib() { return pSib; }
        !            47:     BOOL        IsOpen() { return fOpen; }
        !            48:     
        !            49:     DISPOBJ()
        !            50:     {
        !            51:        pParent = pChild = pSib = NULL;
        !            52:        fPrune = fOpen = FALSE;
        !            53:        iLevel = 0;
        !            54:        pRoot = this;
        !            55:     }
        !            56:     
        !            57:     void AddSibling(DISPOBJ * pNew) {
        !            58:        pNew->pParent = pParent;
        !            59:        pNew->iLevel = iLevel;
        !            60:        pNew->pRoot = pRoot;
        !            61:        
        !            62:        if (pSib == NULL) {
        !            63:            pSib = pNew;
        !            64:            return;
        !            65:        }
        !            66:        
        !            67:        DISPOBJ * p = pSib;
        !            68:        while (p->pSib != NULL) {
        !            69:            p = p->pSib;
        !            70:        }
        !            71:        
        !            72:        p->pSib = pNew;
        !            73:        
        !            74:        return;
        !            75:     }
        !            76:     
        !            77:     void AddChild(DISPOBJ * pNew)
        !            78:     {
        !            79:        pNew->pParent = this;
        !            80:        pNew->iLevel = iLevel + 1;
        !            81:        pNew->pRoot = pRoot;
        !            82:        
        !            83:        if (pChild == NULL) {
        !            84:            pChild = pNew;
        !            85:            return;
        !            86:        }
        !            87:        
        !            88:        pChild->AddSibling(pNew);
        !            89:        return;
        !            90:     }
        !            91:     
        !            92:     virtual void DoForeground(CDC * cdc, BOOL fZoom, RANGESTRUCT * prs) = 0;
        !            93:     
        !            94:     void PaintTree(CDC * cdc, BOOL fZoom, RANGESTRUCT * prs, RECT rt);
        !            95:     void DoBackground( CDC * cdc, CBrush * pBrushBack = &CbrushBackground,
        !            96:                       CBrush * pBrushFrame = &CbrushFrame) {
        !            97:        cdc->FillRect( &rtArea, pBrushBack );
        !            98:        cdc->FrameRect( &rtArea, pBrushFrame );
        !            99: 
        !           100:         return;
        !           101:     }
        !           102:     
        !           103:     
        !           104:     void Close()
        !           105:     {
        !           106:        DISPOBJ * p;
        !           107:        fOpen = FALSE;
        !           108:        
        !           109:        if (pChild && (pChild->fOpen)) {
        !           110:            p = pChild;
        !           111:            while (p != NULL) {
        !           112:                p->Close();
        !           113:                p = p->pSib;
        !           114:            }
        !           115:        }
        !           116:        return;
        !           117:     }
        !           118:     
        !           119:     void ExpandAll()
        !           120:     {
        !           121:        if (pSib) {
        !           122:            pSib->ExpandAll();
        !           123:        }
        !           124: 
        !           125:        if (pChild) {
        !           126:            pChild->ExpandAll();
        !           127:        }
        !           128:        
        !           129:        Open();
        !           130:     }
        !           131:     
        !           132:     void Open() {
        !           133:        
        !           134:        if (fOpen || (pChild == NULL)) {
        !           135:            return;
        !           136:        }
        !           137:        
        !           138:        fOpen = TRUE;
        !           139:     }
        !           140:     
        !           141:     virtual int Height(BOOL fZoom) = 0;
        !           142:     virtual int Width(BOOL fZoom) = 0;
        !           143:     
        !           144:   private:
        !           145:     void  SetPropOnOne(int flags, RANGESTRUCT * prs, CDC * pcdc, BOOL fZoom, TIMETYPE t);
        !           146:     
        !           147: public:
        !           148: 
        !           149:     void SetProperties(int flags, RANGESTRUCT * prs = 0, CDC * pcdc = 0, BOOL fZoom = FALSE, TIMETYPE progTime = 0);
        !           150:     virtual void DoSetPercents(TIMETYPE t) = 0;
        !           151:     virtual void DoSetColors(RANGESTRUCT * prs) = 0;
        !           152:     virtual void DoSetString(void) = 0;
        !           153:     virtual void DoAssignSize(CDC * pcdc) = 0;
        !           154:     void DoSetLocation(BOOL fZoom, BOOL fPrep);
        !           155:            
        !           156:      
        !           157:      BOOL DblClick( CPoint pt )
        !           158:      {
        !           159:         if (rtArea.PtInRect( pt )) {
        !           160:             if (fOpen) {
        !           161:                 Close();
        !           162:             } else {
        !           163:                 Open();
        !           164:             }
        !           165:             return TRUE;
        !           166:         }
        !           167:         
        !           168:         if (fOpen && pChild && pChild->DblClick( pt ) ) {
        !           169:             return TRUE;
        !           170:         }
        !           171:         
        !           172:         if (pSib && pSib->DblClick( pt ) ) {
        !           173:             return TRUE;
        !           174:         }
        !           175:         
        !           176:         return FALSE;
        !           177:      }
        !           178: };
        !           179:   

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