POLYWIN.CPP

/* 
 * POLYWIN.CPP 
 * Polyline Component Chapter 8 
 * 
 * Window procedure for the polyline drawing window and support 
 * functions. 
 * 
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Microsoft 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#include "polyline.h" 
 
 
/* 
 * PolylineWndProc 
 * 
 * Purpose: 
 *  Window procedure for the polyline drawing window. 
 */ 
 
LRESULT APIENTRY PolylineWndProc(HWND hWnd, UINT iMsg 
    , WPARAM wParam, LPARAM lParam) 
    { 
    PCPolyline      ppl; 
    PAINTSTRUCT     ps; 
    HDC             hDC; 
    POINTS          pt; 
    RECT            rc; 
 
    ppl=(PCPolyline)GetWindowLong(hWnd, PLWL_STRUCTURE); 
 
    switch (iMsg) 
        { 
        case WM_CREATE: 
            ppl=(PCPolyline)((LPCREATESTRUCT)lParam)->lpCreateParams; 
            SetWindowLong(hWnd, PLWL_STRUCTURE, (LONG)ppl); 
 
            //New repaints this window, so store the hWnd here. 
            ppl->m_hWnd=hWnd; 
            ppl->m_pImpIPolyline->New(); 
            break; 
 
 
        case WM_PAINT: 
            hDC=BeginPaint(hWnd, &ps); 
            ppl->Draw(hDC, FALSE, TRUE); 
            EndPaint(hWnd, &ps); 
            break; 
 
 
        case WM_LBUTTONDOWN: 
            //Stop if we are already at the limit. 
            if (CPOLYLINEPOINTS==ppl->m_pl.cPoints) 
                { 
                MessageBeep(0); 
                break; 
                } 
 
            //Convert the points into 0-32767 range 
            GetClientRect(hWnd, &rc); 
            pt=MAKEPOINTS(lParam); 
            ppl->PointScale(&rc, &pt, FALSE); 
 
            ppl->m_pl.rgpt[ppl->m_pl.cPoints++]=pt; 
 
            //Draw the lines to this new point only. 
            hDC=GetDC(hWnd); 
            ppl->Draw(hDC, FALSE, FALSE); 
            ReleaseDC(hWnd, hDC); 
 
            if (NULL!=ppl->m_pAdv) 
                ppl->m_pAdv->OnPointChange(); 
 
            break; 
 
 
        default: 
            return DefWindowProc(hWnd, iMsg, wParam, lParam); 
        } 
 
    return 0L; 
    } 
 
 
 
 
 
 
 
/* 
 * CPolyline::Draw 
 * 
 * Purpose: 
 *  Paints the current line in the polyline window. 
 * 
 * Parameters: 
 *  hDC             HDC to draw on, a metafile or printer DC. 
 *  fMetafile       BOOL indicating if hDC is a metafile or not, 
 *                  so we can avoid operations that RIP. 
 *  fEntire         BOOL indicating if we should draw the entire 
 *                  figure or not. 
 * 
 * Return Value: 
 *  None 
 */ 
 
void CPolyline::Draw(HDC hDC, BOOL fMetafile, BOOL fEntire) 
    { 
    HBRUSH          hBrush; 
    HPEN            hPen; 
    HGDIOBJ         hObj1, hObj2; 
    UINT            i, j; 
    UINT            uMM; 
    POINTS          pt1, pt2; 
    POINT           rgpt[CPOLYLINEPOINTS]; 
    RECT            rc; 
 
    GetClientRect(m_hWnd, &rc); 
 
    /* 
     * Make a 32-bit copy of the points in the POLYLINE itself 
     * so we can use DPtoLP and LPtoDP. 
     */ 
    for (i=0; i < m_pl.cPoints; i++) 
        { 
        rgpt[i].x=m_pl.rgpt[i].x; 
        rgpt[i].y=m_pl.rgpt[i].y; 
        } 
 
    /* 
     * If the mapping mode is not MM_TEXT, convert the points to 
     * whatever mapping mode in in effect before drawing. 
     * This specifically supports metafiles in MM_ANISOTROPIC. 
     */ 
    uMM=fMetafile ? MM_TEXT : GetMapMode(hDC); 
 
    if (MM_TEXT!=uMM) 
        DPtoLP(hDC, rgpt, m_pl.cPoints); 
 
    hPen=CreatePen(m_pl.iLineStyle, 1, m_pl.rgbLine); 
    hObj1=SelectObject(hDC, hPen); 
 
    hBrush=CreateSolidBrush(m_pl.rgbBackground); 
    hObj2=SelectObject(hDC, hBrush); 
    SetBkColor(hDC, m_pl.rgbBackground); 
 
    /* 
     * Either draw the entire figure or just a single point.  The 
     * entire figure also includes erasing the background 
     * completely, since hDC may be a metafile DC.  Drawing a single 
     * point just updates the figure for that new point. 
     */ 
    if (fEntire || 0==m_pl.cPoints) 
        { 
        //Erase the background for bitmaps and metafiles. 
        SelectObject(hDC, GetStockObject(NULL_PEN)); 
        Rectangle(hDC, rc.left, rc.top, rc.right+1, rc.bottom+1); 
        SelectObject(hDC, hPen); 
 
 
        /* 
         * If we are drawing the entire figure, then loop through 
         * each point drawing a line to each successive point. 
         */ 
 
        for (i=0; i < m_pl.cPoints; i++) 
            { 
            for (j=i; j < m_pl.cPoints; j++) 
                { 
                pt1.x=(short)rgpt[i].x; 
                pt1.y=(short)rgpt[i].y; 
                pt2.x=(short)rgpt[j].x; 
                pt2.y=(short)rgpt[j].y; 
 
                PointScale(&rc, &pt1, TRUE); 
                PointScale(&rc, &pt2, TRUE); 
                MoveToEx(hDC, pt1.x, pt1.y, NULL); 
                LineTo(hDC, pt2.x, pt2.y); 
                } 
            } 
        } 
    else 
        { 
        /* 
         * If we are only drawing the last point, just cycle once 
         * through previous points. 
         */ 
 
        //Get the last point entered in the array. 
        j=m_pl.cPoints-1; 
        pt1.x=(short)rgpt[j].x; 
        pt1.y=(short)rgpt[j].y; 
        PointScale(&rc, &pt1, TRUE); 
 
        for (i=0; i < j; i++) 
            { 
            pt2.x=(short)rgpt[i].x; 
            pt2.y=(short)rgpt[i].y; 
            PointScale(&rc, &pt2, TRUE); 
 
            MoveToEx(hDC, pt1.x, pt1.y, NULL); 
            LineTo(hDC, pt2.x, pt2.y); 
            } 
        } 
 
    //If we have one point, draw a dot to indicate it's position. 
    if (1==m_pl.cPoints) 
        { 
        pt1.x=(short)rgpt[0].x; 
        pt1.y=(short)rgpt[0].y; 
        PointScale(&rc, &pt1, TRUE); 
        SetPixel(hDC, pt1.x, pt1.y, m_pl.rgbLine); 
        } 
 
    //Restore original points. 
    if (MM_TEXT!=uMM) 
        LPtoDP(hDC, rgpt, m_pl.cPoints); 
 
    SelectObject(hDC, hObj1); 
    SelectObject(hDC, hObj2); 
    DeleteObject(hBrush); 
    DeleteObject(hPen); 
    return; 
    } 
 
 
 
 
 
 
 
/* 
 * CPolyline::PointScale 
 * 
 * Purpose: 
 *  Scales a point to or from a relative window coordinate to a 
 *  0-32767 coordinate. 
 * 
 * Parameters: 
 *  pRect           LPRECT of the window. 
 *  ppt             LPPOINTS to convert 
 *  fScaleToWindow  BOOL indicating direction of scaling. 
 * 
 * Return Value: 
 *  None 
 */ 
 
void CPolyline::PointScale(LPRECT pRect, LPPOINTS ppt 
    , BOOL fScaleToWindow) 
    { 
    DWORD   cx, cy; 
 
    //Window size 
    cx=(DWORD)(pRect->right-pRect->left); 
    cy=(DWORD)(pRect->bottom-pRect->top); 
 
    //Prevent crashes 
    if (0L==cx) cx=1; 
    if (0L==cy) cy=1; 
 
    //Must use DWORD to insure proper scaling. 
    if (fScaleToWindow) 
        { 
        ppt->x=(UINT)(((DWORD)ppt->x*cx) >> 15); 
        ppt->y=(UINT)(((DWORD)ppt->y*cy) >> 15); 
        } 
    else 
        { 
        ppt->x=(UINT)(((DWORD)ppt->x << 15)/cx); 
        ppt->y=(UINT)(((DWORD)ppt->y << 15)/cy); 
        } 
 
    return; 
    }