Return to paint.c CVS log

Up to [WindowsNT SDKs] / mstools / ole20 / samples / gizmobar

Annotation of mstools/ole20/samples/gizmobar/paint.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * PAINT.C
        !             3:  * GizmoBar Version 1.00, March 1993
        !             4:  *
        !             5:  * Contains any code related to GizmoBar visuals, primarily
        !             6:  * the WM_PAINT handler.
        !             7:  *
        !             8:  * Copyright (c)1992 Microsoft Corporation, All Rights Reserved
        !             9:  *
        !            10:  * Kraig Brockschmidt, Software Design Engineer
        !            11:  * Microsoft Systems Developer Relations
        !            12:  *
        !            13:  * Internet  :  [email protected]
        !            14:  * Compuserve:  >INTERNET:[email protected]
        !            15:  */
        !            16: 
        !            17: #ifdef WIN32
        !            18: #define _INC_OLE
        !            19: #define __RPC_H__
        !            20: #endif
        !            21: 
        !            22: 
        !            23: #define STRICT
        !            24: #include <windows.h>
        !            25: #include "gizmoint.h"
        !            26: 
        !            27: 
        !            28: //In GIZMO.C
        !            29: extern TOOLDISPLAYDATA tdd;
        !            30: 
        !            31: 
        !            32: /*
        !            33:  * GizmoBarPaint
        !            34:  *
        !            35:  * Purpose:
        !            36:  *  Handles all WM_PAINT messages for the control and paints either the
        !            37:  *  entire thing or just one GizmoBar button if pGB->pGizmoPaint is non-NULL.
        !            38:  *
        !            39:  * Parameters:
        !            40:  *  hWnd            HWND Handle to the control.
        !            41:  *  pGB             PGIZMOBAR control data pointer.
        !            42:  *
        !            43:  * Return Value:
        !            44:  *  None
        !            45:  */
        !            46: 
        !            47: void GizmoBarPaint(HWND hWnd, PGIZMOBAR pGB)
        !            48:     {
        !            49:     PAINTSTRUCT ps;
        !            50:     RECT        rc;
        !            51:     HDC         hDC;
        !            52:     HBRUSH      hBr=NULL;
        !            53:     HPEN        hPen=NULL;
        !            54: 
        !            55: 
        !            56:     hDC=BeginPaint(hWnd, &ps);
        !            57:     GetClientRect(hWnd, &rc);
        !            58: 
        !            59:     /*
        !            60:      * The only part of the frame we need to draw is the bottom line,
        !            61:      * so we inflate the rectangle such that all other parts are outside
        !            62:      * the visible region.
        !            63:      */
        !            64:     hBr =CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
        !            65: 
        !            66:     if (NULL!=hBr)
        !            67:         SelectObject(hDC, hBr);
        !            68: 
        !            69:     hPen=CreatePen(PS_SOLID, 1, GetSysColor(COLOR_WINDOWFRAME));
        !            70: 
        !            71:     if (NULL!=hPen)
        !            72:         SelectObject(hDC, hPen);
        !            73: 
        !            74:     Rectangle(hDC, rc.left-1, rc.top-1, rc.right+1, rc.bottom);
        !            75: 
        !            76: 
        !            77:     /*
        !            78:      * All that we have to do to draw the controls is start through the
        !            79:      * list, ignoring anything but buttons, and calling BTTNCUR's
        !            80:      * UIToolButtonDraw for buttons.  Since we don't even have to track
        !            81:      * positions of things, we can just use an enum.
        !            82:      */
        !            83:     GizmoPEnum(&pGB->pGizmos, FEnumPaintGizmos, (DWORD)(LPSTR)&ps);
        !            84: 
        !            85:     //Clean up
        !            86:     EndPaint(hWnd, &ps);
        !            87: 
        !            88:     if (NULL!=hBr)
        !            89:         DeleteObject(hBr);
        !            90: 
        !            91:     if (NULL!=hPen)
        !            92:         DeleteObject(hPen);
        !            93: 
        !            94:     return;
        !            95:     }
        !            96: 
        !            97: 
        !            98: 
        !            99: 
        !           100: 
        !           101: /*
        !           102:  * FEnumPaintGizmos
        !           103:  *
        !           104:  * Purpose:
        !           105:  *  Enumeration callback for all the gizmos we know about in order to
        !           106:  *  draw them.
        !           107:  *
        !           108:  * Parameters:
        !           109:  *  pGizmo          PGIZMO to draw.
        !           110:  *  iGizmo          UINT index on the GizmoBar of this gizmo.
        !           111:  *  dw              DWORD extra data passed to GizmoPEnum, in our case
        !           112:  *                  a pointer to the PAINTSTRUCT.
        !           113:  *
        !           114:  * Return Value:
        !           115:  *  BOOL            TRUE to continue the enumeration, FALSE otherwise.
        !           116:  */
        !           117: 
        !           118: BOOL FAR PASCAL FEnumPaintGizmos(PGIZMO pGizmo, UINT iGizmo, DWORD dw)
        !           119:     {
        !           120:     LPPAINTSTRUCT   pps=(LPPAINTSTRUCT)dw;
        !           121:     RECT            rc, rcI;
        !           122: 
        !           123:     //Only draw those marked for repaint.
        !           124:     if ((GIZMOTYPE_DRAWN & pGizmo->iType))
        !           125:         {
        !           126:         SetRect(&rc, pGizmo->x, pGizmo->y, pGizmo->x+pGizmo->dx, pGizmo->y+pGizmo->dy);
        !           127: 
        !           128:         //Only draw gizmos in the repaint area
        !           129:         if (IntersectRect(&rcI, &rc, &pps->rcPaint))
        !           130:             {
        !           131:             UIToolButtonDrawTDD(pps->hdc, pGizmo->x, pGizmo->y
        !           132:                 , pGizmo->dx, pGizmo->dy, pGizmo->hBmp, pGizmo->cxImage
        !           133:                 , pGizmo->cyImage, pGizmo->iBmp, (UINT)pGizmo->uState, &tdd);
        !           134:             }
        !           135:         }
        !           136: 
        !           137:     return TRUE;
        !           138:     }

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