windows-server-2003/admin/controls/smonctrl/hatchwnd.cpp

/*++

Copyright (C) 1996-1999 Microsoft Corporation

Module Name:

    hatchwnd.h

Abstract:

    Implementation of the CHatchWin class.  CHatchWin when used 
    as a parent window creates a thin hatch border around 
    the child window.

--*/
#include <windows.h>
#include <oleidl.h>
#include "hatchwnd.h"
#include "resource.h"
#include "globals.h"

// Hit codes for computing handle code (Y_CODE + 3 * X_CODE)
#define Y_TOP       0
#define Y_MIDDLE    1
#define Y_BOTTOM    2
#define X_LEFT      0
#define X_MIDDLE    1
#define X_RIGHT     2
#define NO_HIT     -1

// Sizing flags
#define SIZING_TOP       0x0001
#define SIZING_BOTTOM    0x0002
#define SIZING_LEFT      0x0004
#define SIZING_RIGHT     0x0008
#define SIZING_ALL       0x0010

// Sizing flags lookup (indexed by handle code)
static UINT uSizingTable[9] = {
    SIZING_LEFT | SIZING_TOP,    SIZING_TOP,    SIZING_RIGHT | SIZING_TOP,
    SIZING_LEFT,                 SIZING_ALL,    SIZING_RIGHT,
    SIZING_LEFT | SIZING_BOTTOM, SIZING_BOTTOM, SIZING_BOTTOM | SIZING_RIGHT };

// Cursor ID lookup (indexed by handle code)
static UINT uCursIDTable[9] = {
    IDC_CURS_NWSE, IDC_CURS_NS,     IDC_CURS_NESW,
    IDC_CURS_WE,   IDC_CURS_MOVE,   IDC_CURS_WE,
    IDC_CURS_NESW, IDC_CURS_NS,     IDC_CURS_NWSE 
};

// Cursors (indexed by cursor ID)
static HCURSOR hCursTable[IDC_CURS_MAX - IDC_CURS_MIN + 1];

#define IDTIMER_DEBOUNCE 1
#define MIN_SIZE 8
        
// Brush patterns
static WORD wHatchBmp[]={0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88};
static WORD wGrayBmp[]={0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa};

static HBRUSH   hBrHatch;
static HBRUSH   hBrGray;

// System parameters
static INT iBorder;
static INT iDragMinDist;
static INT iDragDelay;

static INT fLocalInit = FALSE;

// Forward refs
void DrawShading(HDC, LPRECT);
void DrawHandles (HDC, LPRECT);
void DrawDragRgn (HWND, HRGN);
HRGN CreateDragRgn(LPRECT);

WCHAR   szHatchWinClassName[] = L"Hatchwin" ;

/*
 * CHatchWin:CHatchWin
 * CHatchWin::~CHatchWin
 *
 * Constructor Parameters:
 *  hInst           HINSTANCE of the application we're in.
 */

CHatchWin::CHatchWin(
    VOID
    )
{
    m_hWnd = NULL;
    m_hWndParent = NULL;
    m_hWndKid = NULL;
    m_hWndAssociate = NULL;
    m_hRgnDrag = NULL;

    m_iBorder = 0;
    m_uID = 0;
    m_uDragMode = DRAG_IDLE;
    m_bResizeInProgress = FALSE;
    SetRect(&m_rcPos, 0, 0, 0, 0);
    SetRect(&m_rcClip, 0, 0, 0, 0);

    return;
    }


CHatchWin::~CHatchWin(void)
    {

    if (NULL != m_hWnd)
        DestroyWindow(m_hWnd);

    return;
    }

/*
 * CHatchWin::Init
 *
 * Purpose:
 *  Instantiates a hatch window within a given parent with a
 *  default rectangle.  This is not initially visible.
 *
 * Parameters:
 *  hWndParent      HWND of the parent of this window
 *  uID             UINT identifier for this window (send in
 *                  notifications to associate window).
 *  hWndAssoc       HWND of the initial associate.
 *
 * Return Value:
 *  BOOL            TRUE if the function succeeded, FALSE otherwise.
 */

BOOL CHatchWin::Init(HWND hWndParent, UINT uID, HWND hWndAssoc)
    {
    INT i;
    HBITMAP     hBM;
    WNDCLASS    wc;
    LONG_PTR    lptrID = 0;

    BEGIN_CRITICAL_SECTION

    // If first time through
    if (pstrRegisteredClasses[HATCH_WNDCLASS] == NULL) {

        // Register the hatch window class
        wc.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
        wc.hInstance     = g_hInstance;
        wc.cbClsExtra    = 0;
        wc.lpfnWndProc   = HatchWndProc;
        wc.cbWndExtra    = CBHATCHWNDEXTRA;
        wc.hIcon         = NULL;
        wc.hCursor       = NULL;
        wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
        wc.lpszMenuName  = NULL;
        wc.lpszClassName = szHatchWinClassName;

        if (RegisterClass(&wc)) {

            // Save class name for later unregistering
            pstrRegisteredClasses[HATCH_WNDCLASS] = szHatchWinClassName;

            // Get system metrics
            iBorder = GetProfileInt(TEXT("windows"),
                                    TEXT("OleInPlaceBorderWidth"), 4);
            iDragMinDist = GetProfileInt(TEXT("windows"),
                                        TEXT("DragMinDist"), DD_DEFDRAGMINDIST);
            iDragDelay = GetProfileInt(TEXT("windows"),
                                        TEXT("DragDelay"), DD_DEFDRAGDELAY);

            // Load the arrow cursors
            for (i = IDC_CURS_MIN; i <= IDC_CURS_MAX; i++) {
                hCursTable[i - IDC_CURS_MIN] = LoadCursor(g_hInstance, MAKEINTRESOURCE(i));
            }

            // Create brushes for hatching and drag region
            hBM = CreateBitmap(8, 8, 1, 1, wHatchBmp);
            if ( NULL != hBM ) {
                hBrHatch = CreatePatternBrush(hBM);
                DeleteObject(hBM);
            }

            hBM = CreateBitmap(8, 8, 1, 1, wGrayBmp);
            if ( NULL != hBM ) {
                hBrGray = CreatePatternBrush(hBM);
                DeleteObject(hBM);
            }
        }
    }
    
    END_CRITICAL_SECTION

    if (pstrRegisteredClasses[HATCH_WNDCLASS] == NULL)
        return FALSE;

    lptrID = uID;

    m_hWnd = CreateWindowEx(
                WS_EX_NOPARENTNOTIFY, 
                szHatchWinClassName,
                szHatchWinClassName, 
                WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                0, 
                0, 
                100, 
                100, 
                hWndParent, 
                (HMENU)lptrID, 
                g_hInstance, 
                this);

    m_uID = uID;
    m_hWndAssociate = hWndAssoc;
    m_hWndParent = hWndParent;


    return (NULL != m_hWnd);
}

/*
 * CHatchWin::HwndAssociateSet
 * CHatchWin::HwndAssociateGet
 *
 * Purpose:
 *  Sets (Set) or retrieves (Get) the associate window of the
 *  hatch window.
 *
 * Parameters: (Set only)
 *  hWndAssoc       HWND to set as the associate.
 *
 * Return Value:
 *  HWND            Previous (Set) or current (Get) associate
 *                  window.
 */

HWND CHatchWin::HwndAssociateSet(HWND hWndAssoc)
    {
    HWND hWndT = m_hWndAssociate;

    m_hWndAssociate = hWndAssoc;
    return hWndT;
    }

HWND CHatchWin::HwndAssociateGet(void)
    {
    return m_hWndAssociate;
    }


/*
 * CHatchWin::RectsSet
 *
 * Purpose:
 *  Changes the size and position of the hatch window and the child
 *  window within it using a position rectangle for the child and
 *  a clipping rectangle for the hatch window and child.  The hatch
 *  window occupies prcPos expanded by the hatch border and clipped
 *  by prcClip.  The child window is fit to prcPos to give the
 *  proper scaling, but it clipped to the hatch window which
 *  therefore clips it to prcClip without affecting the scaling.
 *
 * Parameters:
 *  prcPos          LPRECT providing the position rectangle.
 *  prcClip         LPRECT providing the clipping rectangle.
 *
 * Return Value:
 *  None
 */

void CHatchWin::RectsSet(LPRECT prcPos, LPRECT prcClip)
    {
    RECT    rc;
    RECT    rcPos;
    UINT    uPosFlags = SWP_NOZORDER | SWP_NOACTIVATE;
    BOOL    bChanged = TRUE;

    // If new rectangles, save them
    if (prcPos != NULL) {

        bChanged = !EqualRect ( prcPos, &m_rcPos );

        m_rcPos = *prcPos;

        // If clipping rect supplied, use it
        // else just use the position rect again
        if (prcClip != NULL) {
            if ( !bChanged ) 
                bChanged = !EqualRect ( prcClip, &m_rcClip );
            m_rcClip = *prcClip;
        } else {
            m_rcClip = m_rcPos;
        }
    }

    if ( bChanged ) {

        // Expand position rect to include hatch border
        rcPos = m_rcPos;
        InflateRect(&rcPos, m_iBorder, m_iBorder);                             

        // Clip with clipping rect to get actual window rect
        IntersectRect(&rc, &rcPos, &m_rcClip);

        // Save hatch wnd origin relative to clipped window
        m_ptHatchOrg.x = rcPos.left - rc.left;
        m_ptHatchOrg.y = rcPos.top - rc.top;

        // Set flag to avoid reentrant call from window proc
        m_bResizeInProgress = TRUE;

        // Offset child window from hatch rect by border width
        // (maintaining its original size)
        SetWindowPos(m_hWndKid, NULL, m_ptHatchOrg.x + m_iBorder, m_ptHatchOrg.y + m_iBorder, 
                     m_rcPos.right - m_rcPos.left, m_rcPos.bottom - m_rcPos.top, uPosFlags);

        // Position the hatch window
        SetWindowPos(m_hWnd, NULL, rc.left, rc.top, rc.right - rc.left,
                     rc.bottom - rc.top,  uPosFlags);

        m_bResizeInProgress = FALSE;
    }

    // This is here to ensure that the control background gets redrawn
    // On a UI deactivate, the VC test container erases the control window
    // between the WM_ERASEBKGND and WM_PAINT, so the background ends up
    // the container color instead of the control color
    if (m_iBorder == 0)
        InvalidateRect(m_hWndKid, NULL, TRUE);

    return;
    }



/*
 * CHatchWin::ChildSet
 *
 * Purpose:
 *  Assigns a child window to this hatch window.
 *
 * Parameters:
 *  hWndKid         HWND of the child window.
 *
 * Return Value:
 *  None
 */

void CHatchWin::ChildSet(HWND hWndKid)
    {
    m_hWndKid = hWndKid;

    if (NULL != hWndKid)
        {
        SetParent(hWndKid, m_hWnd);

        //Insure this is visible when the hatch window becomes visible.
        ShowWindow(hWndKid, SW_SHOW);
        }

    return;
    }


void CHatchWin::OnLeftDown(INT x, INT y)
{
    m_ptDown.x = x;
    m_ptDown.y = y;

    SetCapture(m_hWnd);

    m_uDragMode = DRAG_PENDING;

    SetTimer(m_hWnd, IDTIMER_DEBOUNCE, iDragDelay, NULL);
}


void CHatchWin::OnLeftUp(void)
{
    switch (m_uDragMode) {

    case DRAG_PENDING:

        KillTimer(m_hWnd, IDTIMER_DEBOUNCE);
        ReleaseCapture();
        break;

    case DRAG_ACTIVE:

        // Erase and release drag region
        if ( NULL != m_hRgnDrag ) {
            DrawDragRgn(m_hWndParent, m_hRgnDrag);
            DeleteObject(m_hRgnDrag);
            m_hRgnDrag = NULL;
        }

        ReleaseCapture();

        // Inform associated window of change
        if ( !EqualRect(&m_rectNew, &m_rcPos) ) {
            SendMessage(m_hWndAssociate, WM_COMMAND, 
                        MAKEWPARAM(m_uID, HWN_RESIZEREQUESTED),
                        (LPARAM)&m_rectNew);
        }
        break;
    }

    m_uDragMode = DRAG_IDLE; 
}


void CHatchWin::OnMouseMove(INT x, INT y)
{
    INT     dx, dy;
    HRGN    hRgnNew, hRgnDiff;
    UINT    uResizeFlags;
    
    INT     iWidth, iHeight;
    INT     xHit, yHit;

    static INT  xPrev, yPrev;


    if (x == xPrev && y == yPrev)
        return;

    xPrev = x;
    yPrev = y;

    switch (m_uDragMode)
    {

    case DRAG_IDLE:

        // Adjust to hatch window coordinates
        x -= m_ptHatchOrg.x;
        y -= m_ptHatchOrg.y;

        iWidth = m_rcPos.right - m_rcPos.left + 2 * m_iBorder;
        iHeight = m_rcPos.bottom - m_rcPos.top + 2 * m_iBorder;

        // Determine if x is within a handle
        if (x <= m_iBorder)
            xHit = X_LEFT;
        else if (x >= iWidth - m_iBorder)
            xHit = X_RIGHT;
        else if (x >= (iWidth - m_iBorder)/2 && x <= (iWidth + m_iBorder)/2)
            xHit = X_MIDDLE;
        else 
            xHit = NO_HIT;

        // Determine is y within a handle
        if (y <= m_iBorder)
            yHit = Y_TOP;
        else if (y >= iHeight - m_iBorder)
            yHit = Y_BOTTOM;
        else if (y > (iHeight - m_iBorder)/2 && y < (iHeight + m_iBorder)/2)
            yHit = Y_MIDDLE;
        else
            yHit = NO_HIT;

        // Compute handle code
        // if no handle hit, set to 4 (drag full object)
        if (xHit != NO_HIT && yHit != NO_HIT)
            m_uHdlCode = xHit + 3 * yHit;
        else
            m_uHdlCode = 4;

        // Set cursor to match handle
        SetCursor(hCursTable[uCursIDTable[m_uHdlCode] - IDC_CURS_MIN]);
        break;

    case DRAG_PENDING:
     
        // Start resize if movement threshold exceeded
        dx = (x >= m_ptDown.x) ? (x - m_ptDown.x) : (m_ptDown.x - x);
        dy = (y >= m_ptDown.y) ? (y - m_ptDown.y) : (m_ptDown.y - y);

        if (dx > iDragMinDist || dy > iDragMinDist) {
            KillTimer(m_hWnd, IDTIMER_DEBOUNCE);

            // Create and display initial drag region
            m_hRgnDrag = CreateDragRgn(&m_rcPos);

            if ( NULL != m_hRgnDrag ) {
                DrawDragRgn(m_hWndParent, m_hRgnDrag);

                // Initialize new rect
                m_rectNew = m_rcPos;

                m_uDragMode = DRAG_ACTIVE;
            }
        }
        break;

    case DRAG_ACTIVE:
        
        dx = x - m_ptDown.x;
        dy = y - m_ptDown.y;

        // Compute new rect by applying deltas to selected edges
        // of original position rect 
        uResizeFlags = uSizingTable[m_uHdlCode];

        if (uResizeFlags & SIZING_ALL) {
            m_rectNew.left = m_rcPos.left + dx;
            m_rectNew.top = m_rcPos.top + dy;
            m_rectNew.right = m_rcPos.right + dx;
            m_rectNew.bottom = m_rcPos.bottom + dy;
        } else {
            if (uResizeFlags & SIZING_TOP) {
                m_rectNew.top = m_rcPos.top + dy;

                if (m_rectNew.bottom - m_rectNew.top < MIN_SIZE)
                    m_rectNew.top = m_rectNew.bottom - MIN_SIZE;
            }

            if (uResizeFlags & SIZING_BOTTOM) {
                m_rectNew.bottom = m_rcPos.bottom + dy;

                if (m_rectNew.bottom - m_rectNew.top < MIN_SIZE)
                    m_rectNew.bottom = m_rectNew.top + MIN_SIZE;
            }
                
            if (uResizeFlags & SIZING_LEFT) {
                m_rectNew.left = m_rcPos.left + dx;

                if (m_rectNew.right - m_rectNew.left < MIN_SIZE)
                    m_rectNew.left = m_rectNew.right - MIN_SIZE;
            }
        
            if (uResizeFlags & SIZING_RIGHT) {
                m_rectNew.right = m_rcPos.right + dx;

                if (m_rectNew.right - m_rectNew.left < MIN_SIZE)
                    m_rectNew.right = m_rectNew.left + MIN_SIZE;
            }
        }
        
        // Compute new drag region
        hRgnNew = CreateDragRgn(&m_rectNew);

        if ( NULL != hRgnNew ) {
            // Repaint difference between old and new regions (No Flicker!)
            hRgnDiff = CreateRectRgn(0,0,0,0);
            if ( NULL != m_hRgnDrag 
                    && NULL != hRgnDiff ) {
                CombineRgn(hRgnDiff, m_hRgnDrag, hRgnNew, RGN_XOR);
                DrawDragRgn(m_hWndParent, hRgnDiff);
            } else {
                DrawDragRgn(m_hWndParent, hRgnNew);
            }

            if ( NULL != hRgnDiff ) {
                DeleteObject ( hRgnDiff );
            }
            // Update current region
            if ( NULL != m_hRgnDrag ) {
                DeleteObject(m_hRgnDrag);
            }
            m_hRgnDrag = hRgnNew;
        }
    }

}

void CHatchWin::OnTimer()
{
    if ( DRAG_PENDING == m_uDragMode ) {
        KillTimer(m_hWnd, IDTIMER_DEBOUNCE); 
        // Create and display initial drag region
        m_hRgnDrag = CreateDragRgn(&m_rcPos);

        if ( NULL != m_hRgnDrag ) {
            DrawDragRgn(m_hWndParent, m_hRgnDrag);
            // Initialize new rect
            m_rectNew = m_rcPos;

            m_uDragMode = DRAG_ACTIVE;

        }
    }
}

void CHatchWin::OnPaint()
{
    HDC     hDC;
    RECT    rc;
    PAINTSTRUCT ps;
    INT     iWidth, iHeight;

    hDC = BeginPaint(m_hWnd, &ps);

    // setup hatch rect in window's coord system
    iWidth = m_rcPos.right - m_rcPos.left + 2 * m_iBorder;
    iHeight = m_rcPos.bottom - m_rcPos.top + 2 * m_iBorder;

    SetRect(&rc, m_ptHatchOrg.x, m_ptHatchOrg.y,
                 m_ptHatchOrg.x + iWidth,
                 m_ptHatchOrg.y + iHeight);

    DrawShading(hDC, &rc);
    DrawHandles(hDC, &rc);

    EndPaint(m_hWnd, &ps);
}
    
/*
 * CHatchWin::ShowHatch
 *
 * Purpose:
 *  Turns hatching on and off; turning the hatching off changes
 *  the size of the window to be exactly that of the child, leaving
 *  everything else the same.  The result is that we don't have
 *  to turn off drawing because our own WM_PAINT will never be
 *  called.
 *
 * Parameters:
 *  fHatch          BOOL indicating to show (TRUE) or hide (FALSE)
                    the hatching.
 *
 * Return Value:
 *  None
 */

void CHatchWin::ShowHatch(BOOL fHatch)
{
    /*
     * All we have to do is set the border to zero and
     * call SetRects again with the last rectangles the
     * child sent to us.
    */

    m_iBorder = fHatch ? iBorder : 0;
    RectsSet(NULL, NULL);

    return;
}


/*
 * CHatchWin::Window
 *
 * Purpose:
 *  Returns the window handle associated with this object.
 *
 * Return Value:
 *  HWND            Window handle for this object
 */

HWND CHatchWin::Window(void)
    {
    return m_hWnd;
    }

/*
 * HatchWndProc
 *
 * Purpose:
 *  Standard window procedure for the Hatch Window
 */

LRESULT APIENTRY HatchWndProc(HWND hWnd, UINT iMsg
    , WPARAM wParam, LPARAM lParam)
    {
    PCHatchWin  phw;
    
    phw = (PCHatchWin)GetWindowLongPtr(hWnd, HWWL_STRUCTURE);

    switch (iMsg)
        {
        case WM_CREATE:
            phw = (PCHatchWin)((LPCREATESTRUCT)lParam)->lpCreateParams;
            SetWindowLongPtr(hWnd, HWWL_STRUCTURE, (INT_PTR)phw);
            break;

        case WM_DESTROY:
            phw->m_hWnd = NULL;
            break;

        case WM_PAINT:
            phw->OnPaint();
            break;

        case WM_SIZE:
            // If this resize is not due to RectsSet then forward it
            // to adjust our internal control window
            if (!phw->m_bResizeInProgress)
            {
                RECT rc;
                POINT pt;

                // Get new rect in container coords
                GetWindowRect(hWnd, &rc);

                // Convert to parent client coords
                pt.x = pt.y = 0;
                ClientToScreen(GetParent(hWnd), &pt);
                OffsetRect(&rc,-pt.x, -pt.y);

                // Resize control
                phw->RectsSet(&rc, NULL);
            }
            break;

        case WM_MOUSEMOVE:
            phw->OnMouseMove((short)LOWORD(lParam),(short)HIWORD(lParam));
            break;

        case WM_LBUTTONDOWN:
            phw->OnLeftDown((short)LOWORD(lParam),(short)HIWORD(lParam));
            break;

        case WM_LBUTTONUP:
            phw->OnLeftUp();
            break;

        case WM_TIMER:
            phw->OnTimer();
            break;

        case WM_SETFOCUS:
            //We need this since the container will SetFocus to us.
            if (NULL != phw->m_hWndKid)
                SetFocus(phw->m_hWndKid);
            break;

        case WM_LBUTTONDBLCLK:
            /*
             * If the double click was within m_dBorder of an
             * edge, send the HWN_BORDERDOUBLECLICKED notification.
             *
             * Because we're always sized just larger than our child
             * window by the border width, we can only *get* this
             * message when the mouse is on the border.  So we can
             * just send the notification.
             */

            if (NULL!=phw->m_hWndAssociate)
                {
                SendMessage(phw->m_hWndAssociate, WM_COMMAND, 
                            MAKEWPARAM(phw->m_uID,HWN_BORDERDOUBLECLICKED),
                            (LPARAM)hWnd);
                }

            break;

        default:
            return DefWindowProc(hWnd, iMsg, wParam, lParam);
        }
    
    return 0L;
    }


HRGN CreateDragRgn(LPRECT pRect)
{
    HRGN    hRgnIn;
    HRGN    hRgnOut;
    HRGN    hRgnRet = NULL;

    if ( NULL != pRect ) {
  
        hRgnRet = CreateRectRgn(0,0,0,0);

        hRgnIn = CreateRectRgn(pRect->left, pRect->top,pRect->right, pRect->bottom);
        hRgnOut = CreateRectRgn(pRect->left - iBorder, pRect->top - iBorder,
                                pRect->right + iBorder, pRect->bottom + iBorder);

        if ( NULL != hRgnOut 
                && NULL != hRgnIn
                && NULL != hRgnRet ) {
            CombineRgn(hRgnRet, hRgnOut, hRgnIn, RGN_DIFF);
        }
        if ( NULL != hRgnIn ) {
            DeleteObject(hRgnIn);
        }
        if ( NULL != hRgnOut ) {
            DeleteObject(hRgnOut);
        }
    }
    return hRgnRet;
}


void DrawDragRgn(HWND hWnd, HRGN hRgn)
{
    LONG    lWndStyle;
    INT     iMapMode;
    HDC     hDC;
    RECT    rc;
    HBRUSH  hBr;
    COLORREF    crText;

    // Turn off clipping by children
    lWndStyle = GetWindowLong(hWnd, GWL_STYLE);
    SetWindowLong(hWnd, GWL_STYLE, lWndStyle & ~WS_CLIPCHILDREN);

    // Prepare DC
    hDC = GetDC(hWnd);

    if ( NULL != hDC ) {
        iMapMode = SetMapMode(hDC, MM_TEXT);
        hBr = (HBRUSH)SelectObject(hDC, hBrGray);
        crText = SetTextColor(hDC, RGB(255, 255, 255));

        SelectClipRgn(hDC, hRgn);
        GetClipBox(hDC, &rc);

        PatBlt(hDC, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATINVERT);

        // Restore DC
        SelectObject(hDC, hBr);
        SetTextColor(hDC, crText);
        SetMapMode(hDC, iMapMode);
        SelectClipRgn(hDC, NULL);
        ReleaseDC(hWnd, hDC);
    }

    SetWindowLong(hWnd, GWL_STYLE, lWndStyle);
}


/*
 * DrawShading
 *
 * Purpose:
 *  Draw a hatch border ourside the rectable given.
 *
 * Parameters:
 *  prc             LPRECT containing the rectangle.
 *  hDC             HDC on which to draw.
 *  cWidth          UINT width of the border to draw.  Ignored
 *                  if dwFlags has UI_SHADE_FULLRECT.
 *
 * Return Value:
 *  None
 */

void DrawShading(HDC hDC, LPRECT prc)
{
    HBRUSH      hBROld;
    RECT        rc;
    UINT        cx, cy;
    COLORREF    crText;
    COLORREF    crBk;
    const DWORD dwROP = 0x00A000C9L;  //DPa

    if (NULL==prc || NULL==hDC)
        return;

    hBROld = (HBRUSH)SelectObject(hDC, hBrHatch);

    rc = *prc;
    cx = rc.right - rc.left;
    cy = rc.bottom - rc.top;

    crText = SetTextColor(hDC, RGB(255, 255, 255));
    crBk = SetBkColor(hDC, RGB(0, 0, 0));

    PatBlt(hDC, rc.left, rc.top, cx, iBorder, dwROP);
    PatBlt(hDC, rc.left, rc.top, iBorder, cy, dwROP);
    PatBlt(hDC, rc.right-iBorder, rc.top, iBorder, cy, dwROP);
    PatBlt(hDC, rc.left, rc.bottom-iBorder, cx, iBorder, dwROP);

    SetTextColor(hDC, crText);
    SetBkColor(hDC, crBk);
    SelectObject(hDC, hBROld);

    return;
}

void DrawHandles (HDC hDC, LPRECT prc)
{
    HPEN    hPenOld;
    HBRUSH  hBROld;
    INT     left,right,top,bottom;

#define DrawHandle(x,y) Rectangle(hDC, x, y, (x) + iBorder + 1, (y) + iBorder + 1)

    hPenOld = (HPEN)SelectObject(hDC, (HPEN)GetStockObject(BLACK_PEN));
    hBROld = (HBRUSH)SelectObject(hDC, (HBRUSH)GetStockObject(BLACK_BRUSH));

    left = prc->left;
    right = prc->right - iBorder;
    top = prc->top;
    bottom = prc->bottom - iBorder;
     
    DrawHandle(left, top);
    DrawHandle(left, (top + bottom)/2);
    DrawHandle(left, bottom);

    DrawHandle(right, top);
    DrawHandle(right, (top + bottom)/2);
    DrawHandle(right, bottom);

    DrawHandle((left + right)/2, top);
    DrawHandle((left + right)/2, bottom);

    SelectObject(hDC, hPenOld);
    SelectObject(hDC, hBROld);
}