windows-xp/Source/XPSP1/NT/net/mmc/dhcp/classed.c

/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1993-1994
*
*  TITLE:       CLASSED.C
*
*  VERSION:     5.01
*
*  AUTHOR:      Tracy Sharpe
*
*  DATE:        05 Mar 1994
*
*  Binary edit dialog for use by the Registry Editor.
*
*  Hexadecimal editor control for use by the Registry Editor.  Little attempt
*  is made to make this a generic control-- only one instance is assumed to
*  ever exist.
*
*  02 Oct 1997 modified to work with the DHCP snapin
*
*******************************************************************************/

#include <windows.h>
#include <windowsx.h>
#include <stdlib.h>
#include <string.h>
#include <mbstring.h>
#include <tchar.h>
#include "resource.h"
#include "classed.h"
#include "dhcpapi.h"
#include "helparr.h"

//
//  Following structure and data are used to move the controls of the
//  EditBinaryValue dialog so that the HexEdit control fills up the appropriate
//  amount of space based on the system metrics.
//

typedef struct _MOVEWND {
    int ControlID;
    UINT SetWindowPosFlags;
}   MOVEWND;

const TCHAR s_HexEditClassName[] = HEXEDIT_CLASSNAME;

const TCHAR s_HexEditClipboardFormatName[] = TEXT("RegEdit_HexData");

const TCHAR s_HexWordFormatSpec[] = TEXT("%04X");
const TCHAR s_HexByteFormatSpec[] = TEXT("%02X");

COLORREF g_clrWindow;
COLORREF g_clrWindowText;
COLORREF g_clrHighlight;
COLORREF g_clrHighlightText;

PTSTR g_pHelpFileName;

HINSTANCE g_hInstance;

const MOVEWND s_EditBinaryValueMoveWnd[] = {
    IDOK,               SWP_NOSIZE | SWP_NOZORDER,
    IDCANCEL,           SWP_NOSIZE | SWP_NOZORDER,
    IDC_VALUENAME,      SWP_NOMOVE | SWP_NOZORDER,
    IDC_VALUEDATA,      SWP_NOMOVE | SWP_NOZORDER,
    IDC_VALUECOMMENT,   SWP_NOMOVE | SWP_NOZORDER
};

//  Number of bytes that are displayed per line.  NOTE:  Assumptions have been
//  made that this is power of two.
#define BYTES_PER_HEXEDIT_LINE          8
#define BYTES_PER_HEXEDIT_LINE_MASK     0x0007

//
//  This font is used by the HexEdit window for all output.  The lfHeight
//  member is calculated later based on the system configuration.
//

LOGFONT s_HexEditFont = {
    0,                                  //  lfHeight
    0,                                  //  lfWidth
    0,                                  //  lfEscapement
    0,                                  //  lfOrientation
    FW_NORMAL,                          //  lfWeight
    FALSE,                              //  lfItalic
    FALSE,                              //  lfUnderline
    FALSE,                              //  lfStrikeout
    ANSI_CHARSET,                       //  lfCharSet
    OUT_DEFAULT_PRECIS,                 //  lfOutPrecision
    CLIP_DEFAULT_PRECIS,                //  lfClipPrecision
    DEFAULT_QUALITY,                    //  lfQuality
    FIXED_PITCH | FF_DONTCARE,          //  lfPitchAndFamily
    TEXT("Courier")                     //  lfFaceName
};

//  Set if window has input focus, clear if not.
#define HEF_FOCUS                       0x00000001
#define HEF_NOFOCUS                     0x00000000
//  Set if dragging a range with mouse, clear if not.
#define HEF_DRAGGING                    0x00000002
#define HEF_NOTDRAGGING                 0x00000000
//  Set if editing ASCII column, clear if editing hexadecimal column.
#define HEF_CARETINASCIIDUMP            0x00000004
#define HEF_CARETINHEXDUMP              0x00000000
//
#define HEF_INSERTATLOWNIBBLE           0x00000008
#define HEF_INSERTATHIGHNIBBLE          0x00000000
//  Set if caret should be shown at the end of the previous line instead of at
//  the beginning of it's real caret line, clear if not.
#define HEF_CARETATENDOFLINE            0x00000010

HEXEDITDATA s_HexEditData;

typedef struct _HEXEDITCLIPBOARDDATA {
    DWORD cbSize;
    BYTE Data[1];
}   HEXEDITCLIPBOARDDATA, *LPHEXEDITCLIPBOARDDATA;

UINT s_HexEditClipboardFormat;

BOOL
PASCAL
EditBinaryValue_OnInitDialog(
    HWND hWnd,
    HWND hFocusWnd,
    LPARAM lParam
    );

LRESULT
PASCAL
HexEditWndProc(
    HWND hWnd,
    UINT Message,
    WPARAM wParam,
    LPARAM lParam
    );

BOOL
PASCAL
HexEdit_OnNcCreate(
    HWND hWnd,
    LPCREATESTRUCT lpCreateStruct
    );

VOID
PASCAL
HexEdit_OnSize(
    HWND hWnd,
    UINT State,
    int cx,
    int cy
    );

VOID
PASCAL
HexEdit_SetScrollInfo(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_OnVScroll(
    HWND hWnd,
    HWND hCtlWnd,
    UINT Code,
    int Position
    );

VOID
PASCAL
HexEdit_OnPaint(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_PaintRect(
    HWND hWnd,
    HDC hDC,
    LPRECT lpUpdateRect
    );

VOID
PASCAL
HexEdit_OnSetFocus(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_OnKillFocus(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_OnLButtonDown(
    HWND hWnd,
    BOOL fDoubleClick,
    int x,
    int y,
    UINT KeyFlags
    );

VOID
PASCAL
HexEdit_OnMouseMove(
    HWND hWnd,
    int x,
    int y,
    UINT KeyFlags
    );

VOID
PASCAL
HexEdit_OnLButtonUp(
    HWND hWnd,
    int x,
    int y,
    UINT KeyFlags
    );

int
PASCAL
HexEdit_HitTest(
    HEXEDITDATA * pHexEditData,
    int x,
    int y
    );

VOID
PASCAL
HexEdit_OnKey(
    HWND hWnd,
    UINT VirtualKey,
    BOOL fDown,
    int cRepeat,
    UINT Flags
    );

VOID
PASCAL
HexEdit_OnChar(
    HWND hWnd,
    TCHAR Char,
    int cRepeat
    );

VOID
PASCAL
HexEdit_SetCaretPosition(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_EnsureCaretVisible(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_ChangeCaretIndex(
    HWND hWnd,
    int NewCaretIndex,
    BOOL fExtendSelection
    );

VOID
PASCAL
HexEdit_DeleteRange(
    HWND hWnd,
    UINT SourceKey
    );

BOOL
PASCAL
HexEdit_OnCopy(
    HWND hWnd
    );

BOOL
PASCAL
HexEdit_OnPaste(
    HWND hWnd
    );

VOID
PASCAL
HexEdit_OnContextMenu(
    HWND hWnd,
    int x,
    int y
    );

/*******************************************************************************
*
*  EditBinaryValueDlgProc
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
CALLBACK
EditBinaryValueDlgProc(
    HWND hWnd,
    UINT Message,
    WPARAM wParam,
    LPARAM lParam
    )
{

    LPEDITVALUEPARAM lpEditValueParam;
    HEXEDITDATA *    pHexEditData;
    DWORD            dwErr;
    DHCP_CLASS_INFO  ClassInfo;

    switch (Message) {

        case WM_INITDIALOG:
            return EditBinaryValue_OnInitDialog(hWnd, (HWND)(wParam), lParam);

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam)) {

                case IDOK:
                    lpEditValueParam = (LPEDITVALUEPARAM) GetWindowLongPtr(hWnd, DWLP_USER);
                    
                    pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(GetDlgItem(hWnd, IDC_VALUEDATA), GWLP_USERDATA);

                    if (pHexEditData->cbBuffer == 0)
                    {
                        // user didn't enter any data to describe the class
                        TCHAR szText[1024], szCaption[1024];

                        LoadString(g_hInstance, IDS_CLASSID_NO_DATA, szText, sizeof(szText)/sizeof(TCHAR));
                        LoadString(g_hInstance, IDS_SNAPIN_DESC, szCaption, sizeof(szCaption)/sizeof(TCHAR));

                        MessageBox(hWnd, szText, szCaption, MB_OK | MB_ICONSTOP);
                        
                        SetFocus(GetDlgItem(hWnd, IDC_VALUEDATA));

                        break;
                    }

                    lpEditValueParam->cbValueData = pHexEditData->cbBuffer;

                    GetDlgItemText(hWnd, IDC_VALUENAME, lpEditValueParam->pValueName, 256);
                    if ( _tcslen(lpEditValueParam->pValueName) == 0)
                    {
                        TCHAR szText[1024], szCaption[1024];

                        LoadString(g_hInstance, IDS_CLASSID_NO_NAME, szText, sizeof(szText)/sizeof(TCHAR));
                        LoadString(g_hInstance, IDS_SNAPIN_DESC, szCaption, sizeof(szCaption)/sizeof(TCHAR));

                        MessageBox(hWnd, szText, szCaption, MB_OK | MB_ICONSTOP);
                     
                        SetFocus(GetDlgItem(hWnd, IDC_VALUENAME));

                        break;
                    }

                    GetDlgItemText(hWnd, IDC_VALUECOMMENT, lpEditValueParam->pValueComment, 256);
                    
                    // Everything looks good so far, let's try to create the class on the server
                    ClassInfo.ClassName = lpEditValueParam->pValueName;
                    ClassInfo.ClassComment = lpEditValueParam->pValueComment;
                    ClassInfo.ClassDataLength = lpEditValueParam->cbValueData;
                    ClassInfo.ClassData = lpEditValueParam->pValueData;

                    dwErr = DhcpCreateClass((LPTSTR) lpEditValueParam->pServer,
                                            0, 
                                            &ClassInfo);
                    if (dwErr != ERROR_SUCCESS)
                    {
                        DhcpMessageBox(dwErr, MB_OK, NULL, -1);
                        return FALSE;
                    }

                    //  FALL THROUGH

                case IDCANCEL:
                    EndDialog(hWnd, GET_WM_COMMAND_ID(wParam, lParam));
                    break;

                default:
                    return FALSE;

            }
            break;

        case WM_HELP:
            WinHelp(((LPHELPINFO) lParam)-> hItemHandle, g_pHelpFileName,
                HELP_WM_HELP, (ULONG_PTR) (LPVOID) g_aHelpIDs_IDD_CLASSID_NEW);
            break;

        case WM_CONTEXTMENU:
            WinHelp((HWND) wParam, g_pHelpFileName, HELP_CONTEXTMENU,
                (ULONG_PTR) (LPVOID) g_aHelpIDs_IDD_CLASSID_NEW);
            break;

        default:
            return FALSE;

    }

    return TRUE;

}

/*******************************************************************************
*
*  EditBinaryValue_OnInitDialog
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd,
*     hFocusWnd,
*     lParam,
*
*******************************************************************************/

BOOL
PASCAL
EditBinaryValue_OnInitDialog(
    HWND hWnd,
    HWND hFocusWnd,
    LPARAM lParam
    )
{

    LPEDITVALUEPARAM lpEditValueParam;
    RECT Rect;
    int HexEditIdealWidth;
    int dxChange;
    HWND hControlWnd;
    UINT Counter;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(GetDlgItem(hWnd, IDC_VALUEDATA), GWLP_USERDATA);

    SetWindowLongPtr(hWnd, DWLP_USER, lParam);
    lpEditValueParam = (LPEDITVALUEPARAM) lParam;

    SetDlgItemText(hWnd, IDC_VALUENAME, lpEditValueParam->pValueName);

    SendDlgItemMessage(hWnd, IDC_VALUEDATA, HEM_SETBUFFER, (WPARAM)
        lpEditValueParam-> cbValueData, (LPARAM) lpEditValueParam-> pValueData);

    //
    //  Figure out how big the "ideally" size HexEdit should be-- this means
    //  displaying the address, hex dump, ASCII dump, and potentially a scroll
    //  bar.
    //

    GetWindowRect(GetDlgItem(hWnd, IDC_VALUEDATA), &Rect);

    HexEditIdealWidth = pHexEditData->xAsciiDumpStart +
        pHexEditData->FontMaxWidth * (BYTES_PER_HEXEDIT_LINE + 1) +
        GetSystemMetrics(SM_CXVSCROLL) + GetSystemMetrics(SM_CXEDGE) * 2;

    dxChange = HexEditIdealWidth - (Rect.right - Rect.left);

    //
    //  Resize the dialog box.
    //

    GetWindowRect(hWnd, &Rect);

    MoveWindow(hWnd, Rect.left, Rect.top, Rect.right - Rect.left + dxChange,
        Rect.bottom - Rect.top, FALSE);

    //
    //  Resize or move the controls as necessary.
    //

    for (Counter = 0; Counter < (sizeof(s_EditBinaryValueMoveWnd) /
        sizeof(MOVEWND)); Counter++) {

        hControlWnd = GetDlgItem(hWnd,
            s_EditBinaryValueMoveWnd[Counter].ControlID);

        GetWindowRect(hControlWnd, &Rect);

        if (s_EditBinaryValueMoveWnd[Counter].SetWindowPosFlags & SWP_NOSIZE) {

            MapWindowPoints(NULL, hWnd, (LPPOINT) &Rect, 2);
            Rect.left += dxChange;

        }

        else
            Rect.right += dxChange;

        SetWindowPos(hControlWnd, NULL, Rect.left, Rect.top, Rect.right -
            Rect.left, Rect.bottom - Rect.top,
            s_EditBinaryValueMoveWnd[Counter].SetWindowPosFlags);

    }

    SetFocus(GetDlgItem(hWnd, IDC_VALUENAME));

    return TRUE;

    UNREFERENCED_PARAMETER(hFocusWnd);

}

/*******************************************************************************
*
*  RegisterHexEditClass
*
*  DESCRIPTION:
*     Register the HexEdit window class with the system.
*
*  PARAMETERS:
*     (none).
*
*******************************************************************************/

BOOL
PASCAL
RegisterHexEditClass(
    HINSTANCE hInstance
    )
{

    WNDCLASS WndClass;

    g_hInstance = hInstance;

    s_HexEditClipboardFormat =
        RegisterClipboardFormat(s_HexEditClipboardFormatName);

    WndClass.style = CS_DBLCLKS;
    WndClass.lpfnWndProc = HexEditWndProc;
    WndClass.cbClsExtra = 0;
    WndClass.cbWndExtra = 0;
    WndClass.hInstance = g_hInstance;
    WndClass.hIcon = NULL;
    WndClass.hCursor = LoadCursor(NULL, IDC_IBEAM);
    WndClass.hbrBackground = NULL;
    WndClass.lpszMenuName = NULL;
    WndClass.lpszClassName = s_HexEditClassName;

    return (RegisterClass(&WndClass) != 0);

}

/*******************************************************************************
*
*  HexEditWndProc
*
*  DESCRIPTION:
*     Callback procedure for the HexEdit window.
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     Message,
*     wParam,
*     lParam,
*     (returns),
*
*******************************************************************************/

LRESULT
PASCAL
HexEditWndProc(
    HWND hWnd,
    UINT Message,
    WPARAM wParam,
    LPARAM lParam
    )
{
    HEXEDITDATA * pHexEditData;

    switch (Message) {

        HANDLE_MSG(hWnd, WM_NCCREATE, HexEdit_OnNcCreate);
        HANDLE_MSG(hWnd, WM_SIZE, HexEdit_OnSize);
        HANDLE_MSG(hWnd, WM_VSCROLL, HexEdit_OnVScroll);
        HANDLE_MSG(hWnd, WM_PAINT, HexEdit_OnPaint);
        HANDLE_MSG(hWnd, WM_LBUTTONDOWN, HexEdit_OnLButtonDown);
        HANDLE_MSG(hWnd, WM_LBUTTONDBLCLK, HexEdit_OnLButtonDown);
        HANDLE_MSG(hWnd, WM_MOUSEMOVE, HexEdit_OnMouseMove);
        HANDLE_MSG(hWnd, WM_LBUTTONUP, HexEdit_OnLButtonUp);
        HANDLE_MSG(hWnd, WM_CHAR, HexEdit_OnChar);
        HANDLE_MSG(hWnd, WM_KEYDOWN, HexEdit_OnKey);

        case WM_SETFOCUS:
            HexEdit_OnSetFocus(hWnd);
            break;

        case WM_KILLFOCUS:
            HexEdit_OnKillFocus(hWnd);
            break;

        case WM_TIMER:
            pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
            HexEdit_OnMouseMove(hWnd, pHexEditData->xPrevMessagePos,
                pHexEditData->yPrevMessagePos, 0);
            break;

        case WM_GETDLGCODE:
            return (LPARAM) (DLGC_WANTCHARS | DLGC_WANTARROWS | DLGC_WANTTAB);

        case WM_ERASEBKGND:
            return TRUE;

        case WM_NCDESTROY:
            pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
            if (pHexEditData)
            {
                DeleteObject(pHexEditData->hFont);
                free(pHexEditData);
            }
            break;

        case WM_CONTEXTMENU:
            HexEdit_OnContextMenu(hWnd, LOWORD(lParam), HIWORD(lParam));
            break;

        //  Message: HEM_SETBUFFER
        //  wParam:  Number of bytes in the buffer.
        //  lParam:  Pointer to the buffer.
        case HEM_SETBUFFER:
            pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
            pHexEditData->pBuffer = (PBYTE) lParam;
            pHexEditData->cbBuffer = (int) wParam;

            pHexEditData->CaretIndex = 0;
            pHexEditData->MinimumSelectedIndex = 0;
            pHexEditData->MaximumSelectedIndex = 0;

            pHexEditData->FirstVisibleLine = 0;

            HexEdit_SetScrollInfo(hWnd);

            break;

        default:
            return DefWindowProc(hWnd, Message, wParam, lParam);

    }

    return 0;

}

/*******************************************************************************
*
*  HexEdit_OnNcCreate
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

BOOL
PASCAL
HexEdit_OnNcCreate(
    HWND hWnd,
    LPCREATESTRUCT lpCreateStruct
    )
{

    HDC hDC;
    HFONT hPrevFont;
    TEXTMETRIC TextMetric;
    RECT    rect;
    BOOL    fDone = FALSE;
    int     nPoint = 10;  // starting point size
    int HexEditIdealWidth;

    HEXEDITDATA * pHexEditData = malloc(sizeof(HEXEDITDATA));
    if (!pHexEditData)
        return FALSE;

    SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR) pHexEditData);

    g_clrHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT);
    g_clrHighlight = GetSysColor(COLOR_HIGHLIGHT);

    g_clrWindowText = GetSysColor(COLOR_WINDOWTEXT);
    g_clrWindow = GetSysColor(COLOR_WINDOW);

    pHexEditData->cbBuffer = 0;

    pHexEditData->Flags = 0;

    pHexEditData->cxWindow = 0;
    pHexEditData->cyWindow = 0;
 
    pHexEditData->hFont = NULL;

    hDC = GetDC(hWnd);
    if (hDC)
    {
        GetWindowRect(hWnd, &rect);

        while (!fDone)
        {
            s_HexEditFont.lfHeight = -(nPoint * GetDeviceCaps(hDC, LOGPIXELSY) / 72);

            if ((pHexEditData->hFont = CreateFontIndirect(&s_HexEditFont)) != NULL) 
            {
                hPrevFont = SelectObject(hDC, pHexEditData->hFont);
                GetTextMetrics(hDC, &TextMetric);
                SelectObject(hDC, hPrevFont);

                pHexEditData->FontHeight = TextMetric.tmHeight;

                pHexEditData->LinesVisible = pHexEditData->cyWindow /
                    pHexEditData->FontHeight;

                pHexEditData->FontMaxWidth = TextMetric.tmMaxCharWidth;

                pHexEditData->xHexDumpByteWidth = pHexEditData->FontMaxWidth * 3;
                pHexEditData->xHexDumpStart = pHexEditData->FontMaxWidth * 11 / 2;
                pHexEditData->xAsciiDumpStart = pHexEditData->xHexDumpStart +
                    BYTES_PER_HEXEDIT_LINE * pHexEditData->xHexDumpByteWidth +
                    pHexEditData->FontMaxWidth * 3 / 2;

                // check to make sure we have room 
                HexEditIdealWidth = pHexEditData->xAsciiDumpStart +
                    pHexEditData->FontMaxWidth * (BYTES_PER_HEXEDIT_LINE) +
                    GetSystemMetrics(SM_CXVSCROLL) + GetSystemMetrics(SM_CXEDGE) * 2;

                if (HexEditIdealWidth < (rect.right - rect.left) ||
                    (nPoint < 5) )
                {
                    fDone = TRUE;
                }
                else
                {
                    // try a smaller size
                    DeleteObject(pHexEditData->hFont);
                    pHexEditData->hFont = NULL;
                    nPoint--;
                }
            }
            else
            {
                break;
            }
        }

        ReleaseDC(hWnd, hDC);
    }

    if (pHexEditData->hFont == NULL)
        return FALSE;

    return (BOOL) DefWindowProc(hWnd, WM_NCCREATE, 0, (LPARAM) lpCreateStruct);

}

/*******************************************************************************
*
*  HexEdit_OnSize
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnSize(
    HWND hWnd,
    UINT State,
    int cx,
    int cy
    )
{
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
    
    pHexEditData->cxWindow = cx;
    pHexEditData->cyWindow = cy;

    pHexEditData->LinesVisible = cy / pHexEditData->FontHeight;

    HexEdit_SetScrollInfo(hWnd);

    UNREFERENCED_PARAMETER(State);
    UNREFERENCED_PARAMETER(cx);

}

/*******************************************************************************
*
*  HexEdit_SetScrollInfo
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
PASCAL
HexEdit_SetScrollInfo(
    HWND hWnd
    )
{
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
    SCROLLINFO ScrollInfo;

    pHexEditData->MaximumLines = (pHexEditData->cbBuffer +
        BYTES_PER_HEXEDIT_LINE) / BYTES_PER_HEXEDIT_LINE - 1;

    ScrollInfo.cbSize = sizeof(SCROLLINFO);
    ScrollInfo.fMask = (SIF_RANGE | SIF_PAGE | SIF_POS);
    ScrollInfo.nMin = 0;
    ScrollInfo.nMax = pHexEditData->MaximumLines;
    ScrollInfo.nPage = pHexEditData->LinesVisible;
    ScrollInfo.nPos = pHexEditData->FirstVisibleLine;

    SetScrollInfo(hWnd, SB_VERT, &ScrollInfo, TRUE);

}

/*******************************************************************************
*
*  HexEdit_OnVScroll
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnVScroll(
    HWND hWnd,
    HWND hCtlWnd,
    UINT Code,
    int Position
    )
{

    int NewFirstVisibleLine;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
    SCROLLINFO ScrollInfo;

    NewFirstVisibleLine = pHexEditData->FirstVisibleLine;

    switch (Code) {

        case SB_LINEUP:
            NewFirstVisibleLine--;
            break;

        case SB_LINEDOWN:
            NewFirstVisibleLine++;
            break;

        case SB_PAGEUP:
            NewFirstVisibleLine -= pHexEditData->LinesVisible;
            break;

        case SB_PAGEDOWN:
            NewFirstVisibleLine += pHexEditData->LinesVisible;
            break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            NewFirstVisibleLine = Position;
            break;

    }

    //
    //  Change the scroll bar position.  Note that SetScrollInfo will take into
    //  account the clipping between zero and the maximum value.  It will also
    //  return the final scroll bar position.
    //

    ScrollInfo.cbSize = sizeof(SCROLLINFO);
    ScrollInfo.fMask = SIF_POS;
    ScrollInfo.nPos = NewFirstVisibleLine;

    NewFirstVisibleLine = SetScrollInfo(hWnd, SB_VERT, &ScrollInfo, TRUE);

    if (pHexEditData->FirstVisibleLine != NewFirstVisibleLine) {

        ScrollWindowEx(hWnd, 0, (pHexEditData->FirstVisibleLine -
            NewFirstVisibleLine) * pHexEditData->FontHeight, NULL, NULL, NULL,
            NULL, SW_INVALIDATE);

        pHexEditData->FirstVisibleLine = NewFirstVisibleLine;

        HexEdit_SetCaretPosition(hWnd);

    }

    UNREFERENCED_PARAMETER(hCtlWnd);

}

/*******************************************************************************
*
*  HexEdit_OnPaint
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnPaint(
    HWND hWnd
    )
{

    PAINTSTRUCT PaintStruct;

    BeginPaint(hWnd, &PaintStruct);

    HexEdit_PaintRect(hWnd, PaintStruct.hdc, &PaintStruct.rcPaint);

    EndPaint(hWnd, &PaintStruct);

}

/*******************************************************************************
*
*  HexEdit_PaintRect
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
PASCAL
HexEdit_PaintRect(
    HWND hWnd,
    HDC hDC,
    LPRECT lpUpdateRect
    )
{

    HFONT hPrevFont;
    int CurrentByteIndex;
    BYTE Byte;
    int CurrentLine;
    int LastLine;
    int BytesOnLastLine;
    int BytesOnLine;
    BOOL fUsingHighlight;
    int Counter;
    TCHAR Buffer[5];                     //  Room for four hex digits plus null
    RECT TextRect;
    RECT AsciiTextRect;
    int x;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    if (pHexEditData->hFont)
        hPrevFont = SelectFont(hDC, pHexEditData->hFont);

    SetBkColor(hDC, g_clrWindow);
    SetTextColor(hDC, g_clrWindowText);

    //
    //  Figure out the range of lines of the control that must be painted.
    //  Using this information we can compute the offset into the buffer to
    //  start reading from.
    //

    CurrentLine = lpUpdateRect-> top / pHexEditData->FontHeight;

    TextRect.bottom = CurrentLine * pHexEditData->FontHeight;
    AsciiTextRect.bottom = TextRect.bottom;

    CurrentByteIndex = (pHexEditData->FirstVisibleLine + CurrentLine) *
        BYTES_PER_HEXEDIT_LINE;

    LastLine = lpUpdateRect-> bottom / pHexEditData->FontHeight;

    //
    //  Figure out if there's enough in the buffer to fill up the entire window
    //  and the last line that we paint.
    //

    if (LastLine >= pHexEditData->MaximumLines -
        pHexEditData->FirstVisibleLine) {

        LastLine = pHexEditData->MaximumLines - pHexEditData->FirstVisibleLine;

        BytesOnLastLine = pHexEditData->cbBuffer % BYTES_PER_HEXEDIT_LINE;

    }

    else
        BytesOnLastLine = BYTES_PER_HEXEDIT_LINE;

    BytesOnLine = BYTES_PER_HEXEDIT_LINE;
    fUsingHighlight = FALSE;

    //
    //  Loop through each of the lines to be displayed.
    //

    while (CurrentLine <= LastLine) {

        //
        //  If we're on the last line of the display and this is at the end
        //  of the buffer, we may not have a complete line to paint.
        //

        if (CurrentLine == LastLine)
            BytesOnLine = BytesOnLastLine;

        TextRect.top = TextRect.bottom;
        TextRect.bottom += pHexEditData->FontHeight;

        TextRect.left = 0;
        TextRect.right = pHexEditData->xHexDumpStart;

        x = TextRect.right + pHexEditData->FontMaxWidth / 2;

        wsprintf(Buffer, s_HexWordFormatSpec, CurrentByteIndex);
        ExtTextOut(hDC, 0, TextRect.top, ETO_OPAQUE, &TextRect, Buffer, 4,
            NULL);

        AsciiTextRect.top = AsciiTextRect.bottom;
        AsciiTextRect.bottom += pHexEditData->FontHeight;
        AsciiTextRect.right = pHexEditData->xAsciiDumpStart;

        for (Counter = 0; Counter < BytesOnLine; Counter++,
            CurrentByteIndex++) {

            //
            //  Determine what colors to use to paint the current byte.
            //

            if (CurrentByteIndex >= pHexEditData->MinimumSelectedIndex) {

                if (CurrentByteIndex >= pHexEditData->MaximumSelectedIndex) {

                    if (fUsingHighlight) {

                        fUsingHighlight = FALSE;

                        SetBkColor(hDC, g_clrWindow);
                        SetTextColor(hDC, g_clrWindowText);

                    }

                }

                else {

                    if (!fUsingHighlight) {

                        fUsingHighlight = TRUE;

                        SetBkColor(hDC, g_clrHighlight);
                        SetTextColor(hDC, g_clrHighlightText);

                    }

                }

            }

            Byte = pHexEditData->pBuffer[CurrentByteIndex];

            //
            //  Paint the hexadecimal representation.
            //

            TextRect.left = TextRect.right;
            TextRect.right += pHexEditData->xHexDumpByteWidth;

            wsprintf(Buffer, s_HexByteFormatSpec, Byte);

            ExtTextOut(hDC, x, TextRect.top, ETO_OPAQUE, &TextRect,
                Buffer, 2, NULL);

            x += pHexEditData->xHexDumpByteWidth;

            //
            //  Paint the ASCII representation.
            //

            AsciiTextRect.left = AsciiTextRect.right;
            AsciiTextRect.right += pHexEditData->FontMaxWidth;

            Buffer[0] = (TCHAR) (((Byte & 0x7F) >= ' ') ? Byte : '.');

            ExtTextOut(hDC, AsciiTextRect.left, AsciiTextRect.top, ETO_OPAQUE,
                &AsciiTextRect, Buffer, 1, NULL);

        }

        //
        //  Paint any leftover strips between the hexadecimal and ASCII columns
        //  and the ASCII column and the right edge of the window.
        //

        if (fUsingHighlight) {

            fUsingHighlight = FALSE;

            SetBkColor(hDC, g_clrWindow);
            SetTextColor(hDC, g_clrWindowText);

        }

        TextRect.left = TextRect.right;
        TextRect.right = pHexEditData->xAsciiDumpStart;

        ExtTextOut(hDC, TextRect.left, TextRect.top, ETO_OPAQUE, &TextRect,
            NULL, 0, NULL);

        AsciiTextRect.left = AsciiTextRect.right;
        AsciiTextRect.right = pHexEditData->cxWindow;

        ExtTextOut(hDC, AsciiTextRect.left, AsciiTextRect.top, ETO_OPAQUE,
            &AsciiTextRect, NULL, 0, NULL);

        CurrentLine++;

    }

    //
    //  Paint any remaining space in the control by filling it with the
    //  background color.
    //

    if (TextRect.bottom < lpUpdateRect-> bottom) {

        TextRect.left = 0;
        TextRect.right = pHexEditData->cxWindow;
        TextRect.top = TextRect.bottom;
        TextRect.bottom = lpUpdateRect-> bottom;

        ExtTextOut(hDC, 0, TextRect.top, ETO_OPAQUE, &TextRect, NULL, 0, NULL);

    }

    if (pHexEditData->hFont)
        SelectFont(hDC, hPrevFont);

}

/*******************************************************************************
*
*  HexEdit_OnSetFocus
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnSetFocus(
    HWND hWnd
    )
{
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    pHexEditData->Flags |= HEF_FOCUS;

    CreateCaret(hWnd, NULL, 0, pHexEditData->FontHeight);
    HexEdit_SetCaretPosition(hWnd);
    ShowCaret(hWnd);

}

/*******************************************************************************
*
*  HexEdit_OnKillFocus
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnKillFocus(
    HWND hWnd
    )
{
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    if (pHexEditData->Flags & HEF_FOCUS) {

        pHexEditData->Flags &= ~HEF_FOCUS;

        DestroyCaret();

    }

}

/*******************************************************************************
*
*  HexEdit_OnLButtonDown
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     fDoubleClick, TRUE if this is a double-click message, else FALSE.
*     x, x-coordinate of the cursor relative to the client area.
*     y, y-coordinate of the cursor relative to the client area.
*     KeyFlags, state of various virtual keys.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnLButtonDown(
    HWND hWnd,
    BOOL fDoubleClick,
    int x,
    int y,
    UINT KeyFlags
    )
{

    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
    int NewCaretIndex;

    if (fDoubleClick) {

        if (pHexEditData->CaretIndex + 1 <= pHexEditData->cbBuffer)
        {
            HexEdit_ChangeCaretIndex(hWnd, pHexEditData->CaretIndex + 1, TRUE);
        }
        return;

    }

    NewCaretIndex = HexEdit_HitTest(pHexEditData, x, y);

    HexEdit_ChangeCaretIndex(hWnd, NewCaretIndex, (KeyFlags & MK_SHIFT));

    //
    //  If we don't already have the focus, try to get it.
    //

    if (!(pHexEditData->Flags & HEF_FOCUS))
        SetFocus(hWnd);

    SetCapture(hWnd);
    pHexEditData->Flags |= HEF_DRAGGING;

    pHexEditData->xPrevMessagePos = x;
    pHexEditData->yPrevMessagePos = y;

    SetTimer(hWnd, 1, 400, NULL);

    UNREFERENCED_PARAMETER(fDoubleClick);

}

/*******************************************************************************
*
*  HexEdit_OnMouseMove
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     x, x-coordinate of the cursor relative to the client area.
*     y, y-coordinate of the cursor relative to the client area.
*     KeyFlags, state of various virtual keys.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnMouseMove(
    HWND hWnd,
    int x,
    int y,
    UINT KeyFlags
    )
{

    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
    int NewCaretIndex;

    if (!(pHexEditData->Flags & HEF_DRAGGING))
        return;

    NewCaretIndex = HexEdit_HitTest(pHexEditData, x, y);

    HexEdit_ChangeCaretIndex(hWnd, NewCaretIndex, TRUE);

    pHexEditData->xPrevMessagePos = x;
    pHexEditData->yPrevMessagePos = y;

    {

    int i, j;

    i = y < 0 ? -y : y - pHexEditData->cyWindow;
    j = 400 - ((UINT)i << 4);
    if (j < 100)
        j = 100;
    SetTimer(hWnd, 1, j, NULL);

    }

    UNREFERENCED_PARAMETER(KeyFlags);

}

/*******************************************************************************
*
*  HexEdit_OnLButtonUp
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     x, x-coordinate of the cursor relative to the client area.
*     y, y-coordinate of the cursor relative to the client area.
*     KeyFlags, state of various virtual keys.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnLButtonUp(
    HWND hWnd,
    int x,
    int y,
    UINT KeyFlags
    )
{
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    if (!(pHexEditData->Flags & HEF_DRAGGING))
        return;

    KillTimer(hWnd, 1);

    ReleaseCapture();
    pHexEditData->Flags &= ~HEF_DRAGGING;

    UNREFERENCED_PARAMETER(x);
    UNREFERENCED_PARAMETER(y);
    UNREFERENCED_PARAMETER(KeyFlags);

}

/*******************************************************************************
*
*  HexEdit_HitTest
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     x, x-coordinate of the cursor relative to the client area.
*     y, y-coordinate of the cursor relative to the client area.
*     (returns), index of "hit" byte.
*
*******************************************************************************/

int
PASCAL
HexEdit_HitTest(
    HEXEDITDATA * pHexEditData,
    int x,
    int y
    )
{

    int HitLine;
    int BytesOnHitLine;
    int HitByte;

    //
    //  Figure out which line the user clicked on and how many bytes are on that
    //  line.
    //

    if (y < 0)
        HitLine = -1;

    else if (y >= pHexEditData->cyWindow)
        HitLine = pHexEditData->LinesVisible + 1;

    else
        HitLine = y / pHexEditData->FontHeight;

    HitLine += pHexEditData->FirstVisibleLine;

    if (HitLine >= pHexEditData->MaximumLines) {

        HitLine = pHexEditData->MaximumLines;

        BytesOnHitLine = (pHexEditData->cbBuffer + 1) %
            BYTES_PER_HEXEDIT_LINE;

        if (BytesOnHitLine == 0)
            BytesOnHitLine = BYTES_PER_HEXEDIT_LINE;

    }

    else {

        if (HitLine < 0)
            HitLine = 0;

        BytesOnHitLine = BYTES_PER_HEXEDIT_LINE;

    }

    //
    //
    //

    if (x < pHexEditData->xHexDumpStart)
        x = pHexEditData->xHexDumpStart;

    if (x >= pHexEditData->xHexDumpStart && x <
        pHexEditData->xHexDumpStart + pHexEditData->xHexDumpByteWidth *
        BYTES_PER_HEXEDIT_LINE + pHexEditData->FontMaxWidth) {

        x -= pHexEditData->xHexDumpStart;

        HitByte = x / pHexEditData->xHexDumpByteWidth;

        pHexEditData->Flags &= ~HEF_CARETINASCIIDUMP;

    }

    else {

        HitByte = (x - (pHexEditData->xAsciiDumpStart -
            pHexEditData->FontMaxWidth / 2)) / pHexEditData->FontMaxWidth;

        pHexEditData->Flags |= HEF_CARETINASCIIDUMP;

    }

    //
    //  We allow the user to "hit" the first byte of any line via two ways:
    //      *  clicking before the first byte on that line.
    //      *  clicking beyond the last byte/character of either display of the
    //         previous line.
    //
    //  We would like to see the latter case so that dragging in the control
    //  works naturally-- it's possible to drag to the end of the line to select
    //  the entire range.
    //

    pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;

    if (HitByte >= BytesOnHitLine) {

        if (BytesOnHitLine == BYTES_PER_HEXEDIT_LINE) {

            HitByte = BYTES_PER_HEXEDIT_LINE;
            pHexEditData->Flags |= HEF_CARETATENDOFLINE;

        }

        else
            HitByte = BytesOnHitLine - 1;

    }

    return HitLine * BYTES_PER_HEXEDIT_LINE + HitByte;

}

/*******************************************************************************
*
*  HexEdit_OnKey
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     Char,
*     cRepeat,
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnKey(
    HWND hWnd,
    UINT VirtualKey,
    BOOL fDown,
    int cRepeat,
    UINT Flags
    )
{
    BOOL fControlDown;
    BOOL fShiftDown;
    int NewCaretIndex;
    UINT ScrollCode;
    BOOL bPrevious = FALSE;
    HWND hTabWnd;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    fControlDown = (GetKeyState(VK_CONTROL) < 0);
    fShiftDown = (GetKeyState(VK_SHIFT) < 0);

    NewCaretIndex = pHexEditData->CaretIndex;

    switch (VirtualKey) {

        case VK_TAB:
            if (fShiftDown && !fControlDown)
            {
                // tab to the previous control
                bPrevious = TRUE;
            }
            else 
            if (!fShiftDown && !fControlDown)
            {
                // tab to the next control
                bPrevious = FALSE;
            }

            hTabWnd = GetNextDlgTabItem(GetParent(hWnd), hWnd, bPrevious);
            SetFocus(hTabWnd);
            
            break;

        case VK_UP:
            if (fControlDown)
                break;

            NewCaretIndex -= BYTES_PER_HEXEDIT_LINE;
            goto onkey_CheckLowerBound;

        case VK_DOWN:
            if (fControlDown)
                break;

            NewCaretIndex += BYTES_PER_HEXEDIT_LINE;

            if (NewCaretIndex / BYTES_PER_HEXEDIT_LINE >
                pHexEditData->MaximumLines) {

                if (pHexEditData->Flags & HEF_CARETATENDOFLINE)
                    goto onkey_MoveToEndOfBuffer;

                break;

            }

            goto onkey_CheckUpperBound;

        case VK_HOME:
            if (fControlDown)
                NewCaretIndex = 0;

            else {

                if (pHexEditData->Flags & HEF_CARETATENDOFLINE)
                    NewCaretIndex -= BYTES_PER_HEXEDIT_LINE;

                else
                    NewCaretIndex &= (~BYTES_PER_HEXEDIT_LINE_MASK);

            }

            pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;

            goto onkey_ChangeCaretIndex;

        case VK_END:
            if (fControlDown) {

onkey_MoveToEndOfBuffer:
                pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;
                NewCaretIndex = pHexEditData->cbBuffer;

            }

            else {

                if (pHexEditData->Flags & HEF_CARETATENDOFLINE)
                    break;

                NewCaretIndex = (NewCaretIndex &
                    (~BYTES_PER_HEXEDIT_LINE_MASK)) + BYTES_PER_HEXEDIT_LINE;

                if (NewCaretIndex > pHexEditData->cbBuffer)
                    NewCaretIndex = pHexEditData->cbBuffer;

                else
                    pHexEditData->Flags |= HEF_CARETATENDOFLINE;

            }

            goto onkey_ChangeCaretIndex;

        case VK_PRIOR:
        case VK_NEXT:
            NewCaretIndex -= pHexEditData->FirstVisibleLine *
                BYTES_PER_HEXEDIT_LINE;

            ScrollCode = ((VirtualKey == VK_PRIOR) ? SB_PAGEUP : SB_PAGEDOWN);

            HexEdit_OnVScroll(hWnd, NULL, ScrollCode, 0);

            NewCaretIndex += pHexEditData->FirstVisibleLine *
                BYTES_PER_HEXEDIT_LINE;

            if (VirtualKey == VK_PRIOR)
                goto onkey_CheckLowerBound;

            else
                goto onkey_CheckUpperBound;

        case VK_LEFT:
            if (fControlDown)
            {
                // toggle back and forth between hex and ascii
                if (pHexEditData->Flags & HEF_CARETINASCIIDUMP)
                    pHexEditData->Flags &= ~HEF_CARETINASCIIDUMP;
                else
                    pHexEditData->Flags |= HEF_CARETINASCIIDUMP;
            
                goto onkey_ChangeCaretIndex;
            }

            pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;
            NewCaretIndex--;

onkey_CheckLowerBound:
            if (NewCaretIndex < 0)
                break;

            goto onkey_ChangeCaretIndex;

        case VK_RIGHT:
            if (fControlDown)
            {
                // toggle back and forth between hex and ascii
                if (pHexEditData->Flags & HEF_CARETINASCIIDUMP)
                    pHexEditData->Flags &= ~HEF_CARETINASCIIDUMP;
                else
                    pHexEditData->Flags |= HEF_CARETINASCIIDUMP;
            
                goto onkey_ChangeCaretIndex;
            }

            pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;
            NewCaretIndex++;

onkey_CheckUpperBound:
            if (NewCaretIndex > pHexEditData->cbBuffer)
                NewCaretIndex = pHexEditData->cbBuffer;

onkey_ChangeCaretIndex:
            HexEdit_ChangeCaretIndex(hWnd, NewCaretIndex, fShiftDown);
            break;

        case VK_DELETE:
            if (!fControlDown) {

                if (fShiftDown)
                    HexEdit_OnChar(hWnd, IDKEY_CUT, 0);
                else
                    HexEdit_DeleteRange(hWnd, VK_DELETE);

            }
            break;

        case VK_INSERT:
            if (fShiftDown) {

                if (!fControlDown)
                    HexEdit_OnChar(hWnd, IDKEY_PASTE, 0);

            }

            else if (fControlDown)
                HexEdit_OnChar(hWnd, IDKEY_COPY, 0);
            break;

    }
}

/*******************************************************************************
*
*  HexEdit_OnChar
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     Char,
*     cRepeat,
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnChar(
    HWND hWnd,
    TCHAR Char,
    int cRepeat
    )
{

    PBYTE pCaretByte;
    BYTE NewCaretByte;
    int PrevCaretIndex;
    RECT UpdateRect;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    //
    //  Check for any special control characters.
    //

    switch (Char) {

        case IDKEY_COPY:
            HexEdit_OnCopy(hWnd);
            return;

        case IDKEY_PASTE:
            PrevCaretIndex = pHexEditData->CaretIndex;

            if (HexEdit_OnPaste(hWnd))
                goto UpdateDisplay;

            return;

        case IDKEY_CUT:
            if (!HexEdit_OnCopy(hWnd))
                return;
            //  FALL THROUGH

        case VK_BACK:
            HexEdit_DeleteRange(hWnd, VK_BACK);
            return;

        case VK_TAB:
            return;
    }

    //
    //  Validate and convert the typed character depending on the "column" the
    //  user is typing in.
    //

    if (pHexEditData->Flags & HEF_CARETINASCIIDUMP) {

        if (Char < ' ') {

            MessageBeep(MB_OK);
            return;

        }

        NewCaretByte = (BYTE) Char;

    }

    else {

        Char = (TCHAR) CharLower((LPTSTR) Char);

        if (Char >= '0' && Char <= '9')
            NewCaretByte = (BYTE) (Char - '0');

        else if (Char >= 'a' && Char <= 'f')
            NewCaretByte = (BYTE) (Char - 'a' + 10);

        else {

            MessageBeep(MB_OK);
            return;

        }

    }

    if (!(pHexEditData->Flags & HEF_INSERTATLOWNIBBLE)) {

        //
        //  Check to see if we're inserting while a range is selected.  If so,
        //  delete the range and insert at the start of the range.
        //

        if (pHexEditData->MinimumSelectedIndex !=
            pHexEditData->MaximumSelectedIndex)
            HexEdit_DeleteRange(hWnd, 0);

        //
        //  Verify that we aren't overruning the value data buffer.
        //

        if (pHexEditData->cbBuffer >= MAXDATA_LENGTH) {

            MessageBeep(MB_OK);
            return;

        }

        //
        //  Make room for the new byte by shifting all bytes after the insertion
        //  point down one byte.
        //

        pCaretByte = pHexEditData->pBuffer + pHexEditData->CaretIndex;

        MoveMemory(pCaretByte + 1, pCaretByte, pHexEditData->cbBuffer -
            pHexEditData->CaretIndex);

        pHexEditData->cbBuffer++;

        HexEdit_SetScrollInfo(hWnd);

        if (pHexEditData->Flags & HEF_CARETINASCIIDUMP)
            *pCaretByte = NewCaretByte;

        else {

            pHexEditData->Flags |= HEF_INSERTATLOWNIBBLE;

            *pCaretByte = NewCaretByte << 4;

        }

    }

    else {

        pHexEditData->Flags &= ~HEF_INSERTATLOWNIBBLE;

        *(pHexEditData->pBuffer + pHexEditData->CaretIndex) |= NewCaretByte;

    }

    PrevCaretIndex = pHexEditData->CaretIndex;

    if (!(pHexEditData->Flags & HEF_INSERTATLOWNIBBLE)) {

        pHexEditData->CaretIndex++;

        pHexEditData->MinimumSelectedIndex = pHexEditData->CaretIndex;
        pHexEditData->MaximumSelectedIndex = pHexEditData->CaretIndex;

    }

UpdateDisplay:
    pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;
    HexEdit_EnsureCaretVisible(hWnd);

    UpdateRect.left = 0;
    UpdateRect.right = pHexEditData->cxWindow;
    UpdateRect.top = (PrevCaretIndex / BYTES_PER_HEXEDIT_LINE -
        pHexEditData->FirstVisibleLine) * pHexEditData->FontHeight;
    UpdateRect.bottom = pHexEditData->cyWindow;

    SendMessage(GetParent(hWnd), WM_COMMAND,
                MAKEWPARAM(GetWindowLongPtr(hWnd, GWLP_ID), EN_CHANGE), (LPARAM)hWnd);

    InvalidateRect(hWnd, &UpdateRect, FALSE);

}

/*******************************************************************************
*
*  HexEdit_SetCaretPosition
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_SetCaretPosition(
    HWND hWnd
    )
{

    int CaretByte;
    int xCaret;
    int yCaret;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    CaretByte = pHexEditData->CaretIndex % BYTES_PER_HEXEDIT_LINE;

    yCaret = (pHexEditData->CaretIndex / BYTES_PER_HEXEDIT_LINE -
        pHexEditData->FirstVisibleLine) * pHexEditData->FontHeight;

    //
    //  Check if caret should really be displayed at the end of the previous
    //  line.
    //

    if (pHexEditData->Flags & HEF_CARETATENDOFLINE) {

        CaretByte = BYTES_PER_HEXEDIT_LINE;
        yCaret -= pHexEditData->FontHeight;

    }

    //
    //  Figure out which "column" the user is editing in and thus should have
    //  the caret.
    //

    if (pHexEditData->Flags & HEF_CARETINASCIIDUMP) {

        xCaret = pHexEditData->xAsciiDumpStart + CaretByte *
            pHexEditData->FontMaxWidth;

    }

    else {

        xCaret = pHexEditData->xHexDumpStart + CaretByte *
            pHexEditData->xHexDumpByteWidth;

        if (pHexEditData->Flags & HEF_INSERTATLOWNIBBLE)
            xCaret += pHexEditData->FontMaxWidth * 3 / 2;

    }

    SetCaretPos(xCaret, yCaret);

}

/*******************************************************************************
*
*  HexEdit_EnsureCaretVisible
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_EnsureCaretVisible(
    HWND hWnd
    )
{

    int CaretLine;
    int LastVisibleLine;
    int Delta;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    if (!(pHexEditData->Flags & HEF_FOCUS))
        return;

    CaretLine = pHexEditData->CaretIndex / BYTES_PER_HEXEDIT_LINE;

    //
    //  Check if caret should really be displayed at the end of the previous
    //  line.
    //

    if (pHexEditData->Flags & HEF_CARETATENDOFLINE)
        CaretLine--;

    LastVisibleLine = pHexEditData->FirstVisibleLine +
        pHexEditData->LinesVisible - 1;

    if (CaretLine > LastVisibleLine)
        Delta = LastVisibleLine;

    else if (CaretLine < pHexEditData->FirstVisibleLine)
        Delta = pHexEditData->FirstVisibleLine;

    else
        Delta = -1;

    if (Delta != -1) {

        ScrollWindowEx(hWnd, 0, (Delta - CaretLine) * pHexEditData->FontHeight,
            NULL, NULL, NULL, NULL, SW_INVALIDATE);

        pHexEditData->FirstVisibleLine += CaretLine - Delta;

        HexEdit_SetScrollInfo(hWnd);

    }

    HexEdit_SetCaretPosition(hWnd);

}

/*******************************************************************************
*
*  HexEdit_ChangeCaretIndex
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     NewCaretIndex,
*     fExtendSelection,
*
*******************************************************************************/

VOID
PASCAL
HexEdit_ChangeCaretIndex(
    HWND hWnd,
    int NewCaretIndex,
    BOOL fExtendSelection
    )
{

    int PrevMinimumSelectedIndex;
    int PrevMaximumSelectedIndex;
    int Swap;
    int UpdateRectCount;
    RECT UpdateRect[2];
    BOOL fPrevRangeEmpty;
    HDC hDC;
    int Index;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    pHexEditData->Flags &= ~HEF_INSERTATLOWNIBBLE;

    PrevMinimumSelectedIndex = pHexEditData->MinimumSelectedIndex;
    PrevMaximumSelectedIndex = pHexEditData->MaximumSelectedIndex;

    if (fExtendSelection) {

        if (pHexEditData->CaretIndex == pHexEditData->MaximumSelectedIndex)
            pHexEditData->MaximumSelectedIndex = NewCaretIndex;

        else
            pHexEditData->MinimumSelectedIndex = NewCaretIndex;

        if (pHexEditData->MinimumSelectedIndex >
            pHexEditData->MaximumSelectedIndex) {

            Swap = pHexEditData->MinimumSelectedIndex;
            pHexEditData->MinimumSelectedIndex =
                pHexEditData->MaximumSelectedIndex;
            pHexEditData->MaximumSelectedIndex = Swap;

        }

    }

    else {

        pHexEditData->MinimumSelectedIndex = NewCaretIndex;
        pHexEditData->MaximumSelectedIndex = NewCaretIndex;

    }

    pHexEditData->CaretIndex = NewCaretIndex;

    UpdateRectCount = 0;

    if (pHexEditData->MinimumSelectedIndex > PrevMinimumSelectedIndex) {

        UpdateRect[0].top = PrevMinimumSelectedIndex;
        UpdateRect[0].bottom = pHexEditData->MinimumSelectedIndex;

        UpdateRectCount++;

    }

    else if (pHexEditData->MinimumSelectedIndex < PrevMinimumSelectedIndex) {

        UpdateRect[0].top = pHexEditData->MinimumSelectedIndex;
        UpdateRect[0].bottom = PrevMinimumSelectedIndex;

        UpdateRectCount++;

    }

    if (pHexEditData->MaximumSelectedIndex > PrevMaximumSelectedIndex) {

        UpdateRect[UpdateRectCount].top = PrevMaximumSelectedIndex;
        UpdateRect[UpdateRectCount].bottom = pHexEditData->MaximumSelectedIndex;

        UpdateRectCount++;

    }

    else if (pHexEditData->MaximumSelectedIndex < PrevMaximumSelectedIndex) {

        UpdateRect[UpdateRectCount].top = pHexEditData->MaximumSelectedIndex;
        UpdateRect[UpdateRectCount].bottom = PrevMaximumSelectedIndex;

        UpdateRectCount++;

    }

    if (fPrevRangeEmpty = (PrevMinimumSelectedIndex ==
        PrevMaximumSelectedIndex)) {

        UpdateRect[0].top = pHexEditData->MinimumSelectedIndex;
        UpdateRect[0].bottom = pHexEditData->MaximumSelectedIndex;

        UpdateRectCount = 1;

    }

    if (pHexEditData->MinimumSelectedIndex ==
        pHexEditData->MaximumSelectedIndex) {

        if (!fPrevRangeEmpty) {

            UpdateRect[0].top = PrevMinimumSelectedIndex;
            UpdateRect[0].bottom = PrevMaximumSelectedIndex;

            UpdateRectCount = 1;

        }

        else
            UpdateRectCount = 0;

    }

    if (UpdateRectCount) {

        HideCaret(hWnd);

        hDC = GetDC(hWnd);
        if (hDC)
        {
            for (Index = 0; Index < UpdateRectCount; Index++) 
            {

                UpdateRect[Index].top = (UpdateRect[Index].top /
                    BYTES_PER_HEXEDIT_LINE - pHexEditData->FirstVisibleLine) *
                    pHexEditData->FontHeight;
                UpdateRect[Index].bottom = (UpdateRect[Index].bottom /
                    BYTES_PER_HEXEDIT_LINE - pHexEditData->FirstVisibleLine + 1) *
                    pHexEditData->FontHeight;

                if (UpdateRect[Index].top >= pHexEditData->cyWindow ||
                    UpdateRect[Index].bottom < 0)
                    continue;

                if (UpdateRect[Index].top < 0)
                    UpdateRect[Index].top = 0;

                if (UpdateRect[Index].bottom > pHexEditData->cyWindow)
                    UpdateRect[Index].bottom = pHexEditData->cyWindow;

                HexEdit_PaintRect(hWnd, hDC, &UpdateRect[Index]);
            }
    
            ReleaseDC(hWnd, hDC);
        }

        ShowCaret(hWnd);

    }


    HexEdit_EnsureCaretVisible(hWnd);

}

/*******************************************************************************
*
*  HexEdit_DeleteRange
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
PASCAL
HexEdit_DeleteRange(
    HWND hWnd,
    UINT SourceKey
    )
{

    int MinimumSelectedIndex;
    int MaximumSelectedIndex;
    PBYTE pMinimumSelectedByte;
    int Length;
    RECT UpdateRect;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    pHexEditData->Flags &= ~HEF_CARETATENDOFLINE;

    MinimumSelectedIndex = pHexEditData->MinimumSelectedIndex;
    MaximumSelectedIndex = pHexEditData->MaximumSelectedIndex;

    //
    //  Check to see if a range is selected.  If not, then artificially create
    //  one based on the key that caused this routine to be called.
    //

    if (MinimumSelectedIndex == MaximumSelectedIndex) {

        if (SourceKey == VK_DELETE || pHexEditData->Flags &
            HEF_INSERTATLOWNIBBLE) {

            pHexEditData->Flags &= ~HEF_INSERTATLOWNIBBLE;

            MaximumSelectedIndex++;

            if (MaximumSelectedIndex > pHexEditData->cbBuffer)
                return;

        }

        else if (SourceKey == VK_BACK) {

            MinimumSelectedIndex--;

            if (MinimumSelectedIndex < 0)
                return;

        }

        else
            return;

    }

    //
    //  Compute where to start deleting from and the number of bytes to delete.
    //

    pMinimumSelectedByte = pHexEditData->pBuffer + MinimumSelectedIndex;

    Length = MaximumSelectedIndex - MinimumSelectedIndex;

    //
    //  Delete the bytes and update all appropriate window data.
    //

    MoveMemory(pMinimumSelectedByte, pMinimumSelectedByte + Length,
        pHexEditData->cbBuffer - MaximumSelectedIndex);

    pHexEditData->cbBuffer -= Length;

    pHexEditData->CaretIndex = MinimumSelectedIndex;
    pHexEditData->MinimumSelectedIndex = MinimumSelectedIndex;
    pHexEditData->MaximumSelectedIndex = MinimumSelectedIndex;

    HexEdit_SetScrollInfo(hWnd);

    HexEdit_EnsureCaretVisible(hWnd);

    UpdateRect.left = 0;
    UpdateRect.right = pHexEditData->cxWindow;
    UpdateRect.top = (MinimumSelectedIndex / BYTES_PER_HEXEDIT_LINE -
        pHexEditData->FirstVisibleLine) * pHexEditData->FontHeight;
    UpdateRect.bottom = pHexEditData->cyWindow;

    SendMessage(GetParent(hWnd), WM_COMMAND,
                MAKEWPARAM(GetWindowLongPtr(hWnd, GWLP_ID), EN_CHANGE), (LPARAM)hWnd);

    InvalidateRect(hWnd, &UpdateRect, FALSE);

}

/*******************************************************************************
*
*  HexEdit_OnCopy
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

BOOL
PASCAL
HexEdit_OnCopy(
    HWND hWnd
    )
{

    BOOL fSuccess;
    int cbClipboardData;
    LPBYTE lpStartByte;
    HANDLE hClipboardData;
    LPHEXEDITCLIPBOARDDATA lpClipboardData;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    fSuccess = FALSE;

    cbClipboardData = pHexEditData->MaximumSelectedIndex -
        pHexEditData->MinimumSelectedIndex;

    if (cbClipboardData != 0) {

        lpStartByte = pHexEditData->pBuffer +
            pHexEditData->MinimumSelectedIndex;

        if (OpenClipboard(hWnd)) {

            if ((hClipboardData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
                cbClipboardData + sizeof(HEXEDITCLIPBOARDDATA) - 1)) != NULL) {

                lpClipboardData = (LPHEXEDITCLIPBOARDDATA)
                    GlobalLock(hClipboardData);
                CopyMemory(lpClipboardData-> Data, lpStartByte,
                    cbClipboardData);
                lpClipboardData-> cbSize = cbClipboardData;
                GlobalUnlock(hClipboardData);

                EmptyClipboard();
                SetClipboardData(s_HexEditClipboardFormat, hClipboardData);

                fSuccess = TRUE;

            }

            CloseClipboard();

        }

    }

    return fSuccess;

}

/*******************************************************************************
*
*  HexEdit_OnPaste
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*
*******************************************************************************/

BOOL
PASCAL
HexEdit_OnPaste(
    HWND hWnd
    )
{

    BOOL fSuccess;
    HANDLE hClipboardData;
    LPHEXEDITCLIPBOARDDATA lpClipboardData;
    PBYTE pCaretByte;
    DWORD cbSize;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    fSuccess = FALSE;

    if (pHexEditData->Flags & HEF_INSERTATLOWNIBBLE) {

        pHexEditData->Flags &= ~HEF_INSERTATLOWNIBBLE;
        pHexEditData->CaretIndex++;

    }

    if (OpenClipboard(hWnd)) {

        if ((hClipboardData = GetClipboardData(s_HexEditClipboardFormat)) !=
            NULL) {

            lpClipboardData = (LPHEXEDITCLIPBOARDDATA)
                GlobalLock(hClipboardData);

            if (pHexEditData->cbBuffer + lpClipboardData-> cbSize <=
                MAXDATA_LENGTH) {

                if (pHexEditData->MinimumSelectedIndex !=
                    pHexEditData->MaximumSelectedIndex)
                    HexEdit_DeleteRange(hWnd, VK_BACK);

                //
                //  Make room for the new bytes by shifting all bytes after the
                //  the insertion point down the necessary amount.
                //

                pCaretByte = pHexEditData->pBuffer + pHexEditData->CaretIndex;
                cbSize = lpClipboardData-> cbSize;

                MoveMemory(pCaretByte + cbSize, pCaretByte,
                    pHexEditData->cbBuffer - pHexEditData->CaretIndex);
                CopyMemory(pCaretByte, lpClipboardData-> Data, cbSize);

                pHexEditData->cbBuffer += cbSize;
                pHexEditData->CaretIndex += cbSize;

                HexEdit_SetScrollInfo(hWnd);

                fSuccess = TRUE;

            }

            GlobalUnlock(hClipboardData);

        }

        CloseClipboard();

    }

    return fSuccess;

}

/*******************************************************************************
*
*  HexEdit_OnContextMenu
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     hWnd, handle of HexEdit window.
*     x, horizontal position of the cursor.
*     y, vertical position of the cursor.
*
*******************************************************************************/

VOID
PASCAL
HexEdit_OnContextMenu(
    HWND hWnd,
    int x,
    int y
    )
{

    HMENU hContextMenu;
    HMENU hContextPopupMenu;
    int MenuCommand;
    HEXEDITDATA * pHexEditData = (HEXEDITDATA *) GetWindowLongPtr(hWnd, GWLP_USERDATA);

    //
    //  Give us the focus if we don't already have it.
    //

    if (!(pHexEditData->Flags & HEF_FOCUS))
        SetFocus(hWnd);

    //
    //  Load the HexEdit context menu from our resources.
    //

    if ((hContextMenu = LoadMenu(g_hInstance,
        MAKEINTRESOURCE(IDM_HEXEDIT_CONTEXT))) == NULL)
        return;

    hContextPopupMenu = GetSubMenu(hContextMenu, 0);

    //
    //  Disable editing menu options as appropriate.
    //

    if (pHexEditData->MinimumSelectedIndex ==
        pHexEditData->MaximumSelectedIndex) {

        EnableMenuItem(hContextPopupMenu, IDKEY_COPY, MF_BYCOMMAND | MF_GRAYED);
        EnableMenuItem(hContextPopupMenu, IDKEY_CUT, MF_BYCOMMAND | MF_GRAYED);
        EnableMenuItem(hContextPopupMenu, VK_DELETE, MF_BYCOMMAND | MF_GRAYED);

    }

    if (!IsClipboardFormatAvailable(s_HexEditClipboardFormat))
        EnableMenuItem(hContextPopupMenu, IDKEY_PASTE, MF_BYCOMMAND |
            MF_GRAYED);

    if (pHexEditData->MinimumSelectedIndex == 0 &&
        pHexEditData->MaximumSelectedIndex == pHexEditData->cbBuffer)
        EnableMenuItem(hContextPopupMenu, ID_SELECTALL, MF_BYCOMMAND |
            MF_GRAYED);

    //
    //  Display and handle the selected command.
    //

    MenuCommand = TrackPopupMenuEx(hContextPopupMenu, TPM_RETURNCMD |
        TPM_RIGHTBUTTON | TPM_LEFTALIGN | TPM_TOPALIGN, x, y, hWnd, NULL);

    DestroyMenu(hContextMenu);

    switch (MenuCommand) {

        case IDKEY_COPY:
        case IDKEY_PASTE:
        case IDKEY_CUT:
        case VK_DELETE:
            HexEdit_OnChar(hWnd, (TCHAR) MenuCommand, 0);
            break;

        case ID_SELECTALL:
            pHexEditData->MinimumSelectedIndex = 0;
            pHexEditData->MaximumSelectedIndex = pHexEditData->cbBuffer;
            pHexEditData->CaretIndex = pHexEditData->cbBuffer;
            HexEdit_SetCaretPosition(hWnd);
            InvalidateRect(hWnd, NULL, FALSE);
            break;

    }

}