You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2386 lines
58 KiB
2386 lines
58 KiB
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORP., 1993-1994
|
|
*
|
|
* TITLE: REGBINED.C
|
|
*
|
|
* VERSION: 4.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.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include "pch.h"
|
|
#include "regresid.h"
|
|
#include "reghelp.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");
|
|
|
|
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
|
|
};
|
|
|
|
const DWORD s_EditBinaryValueHelpIDs[] = {
|
|
IDC_VALUEDATA, IDH_REGEDIT_VALUEDATA,
|
|
IDC_VALUENAME, IDH_REGEDIT_VALUENAME,
|
|
0, 0
|
|
};
|
|
|
|
|
|
#define HEM_SETBUFFER (WM_USER + 1)
|
|
|
|
// 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
|
|
};
|
|
|
|
//
|
|
// Reference data for the HexEdit window. Because we only ever expect one
|
|
// instance of this class to exist, we can safely create one instance of this
|
|
// structure now to avoid allocating and managing the structure later.
|
|
//
|
|
|
|
typedef struct _HEXEDITDATA {
|
|
UINT Flags;
|
|
PBYTE pBuffer;
|
|
int cbBuffer;
|
|
int cbBufferMax;
|
|
int cxWindow; // Width of the window
|
|
int cyWindow; // Height of the window
|
|
HFONT hFont; // Font being used for output
|
|
LONG FontHeight; // Height of the above font
|
|
LONG FontMaxWidth; // Maximum width of the above font
|
|
int LinesVisible; // Number of lines can be displayed
|
|
int MaximumLines; // Total number of lines
|
|
int FirstVisibleLine; // Line number of top of display
|
|
int xHexDumpStart;
|
|
int xHexDumpByteWidth;
|
|
int xAsciiDumpStart;
|
|
int CaretIndex;
|
|
int MinimumSelectedIndex;
|
|
int MaximumSelectedIndex;
|
|
int xPrevMessagePos; // Cursor point on last mouse message
|
|
int yPrevMessagePos; // Cursor point on last mouse message
|
|
} HEXEDITDATA;
|
|
|
|
// 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(
|
|
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(
|
|
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:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
INT_PTR
|
|
CALLBACK
|
|
EditBinaryValueDlgProc(
|
|
HWND hWnd,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
|
|
LPEDITVALUEPARAM lpEditValueParam;
|
|
|
|
switch (Message) {
|
|
|
|
HANDLE_MSG(hWnd, WM_INITDIALOG, EditBinaryValue_OnInitDialog);
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
lpEditValueParam = (LPEDITVALUEPARAM) GetWindowLongPtr(hWnd, DWLP_USER);
|
|
// Set these for both "ok" and "cancel",
|
|
// lpEditValueParam->pValueData must again point to the
|
|
// current buffer so it can be returned and deleted
|
|
lpEditValueParam->cbValueData = s_HexEditData.cbBuffer;
|
|
lpEditValueParam->pValueData = s_HexEditData.pBuffer;
|
|
s_HexEditData.pBuffer = NULL;
|
|
|
|
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) s_EditBinaryValueHelpIDs);
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND) wParam, g_pHelpFileName, HELP_CONTEXTMENU,
|
|
(DWORD) (ULONG_PTR) s_EditBinaryValueHelpIDs);
|
|
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;
|
|
|
|
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 = s_HexEditData.xAsciiDumpStart +
|
|
s_HexEditData.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);
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
UNREFERENCED_PARAMETER(hFocusWnd);
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* RegisterHexEditClass
|
|
*
|
|
* DESCRIPTION:
|
|
* Register the HexEdit window class with the system.
|
|
*
|
|
* PARAMETERS:
|
|
* (none).
|
|
*
|
|
*******************************************************************************/
|
|
|
|
BOOL
|
|
PASCAL
|
|
RegisterHexEditClass(
|
|
VOID
|
|
)
|
|
{
|
|
|
|
WNDCLASS WndClass;
|
|
|
|
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
|
|
)
|
|
{
|
|
|
|
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_KEYDOWN, HexEdit_OnKey);
|
|
HANDLE_MSG(hWnd, WM_CHAR, HexEdit_OnChar);
|
|
|
|
case WM_SETFOCUS:
|
|
HexEdit_OnSetFocus(hWnd);
|
|
break;
|
|
|
|
case WM_KILLFOCUS:
|
|
HexEdit_OnKillFocus(hWnd);
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
HexEdit_OnMouseMove(hWnd, s_HexEditData.xPrevMessagePos,
|
|
s_HexEditData.yPrevMessagePos, 0);
|
|
break;
|
|
|
|
case WM_GETDLGCODE:
|
|
return (LPARAM) (DLGC_WANTCHARS | DLGC_WANTARROWS);
|
|
|
|
case WM_ERASEBKGND:
|
|
return TRUE;
|
|
|
|
case WM_NCDESTROY:
|
|
DeleteObject(s_HexEditData.hFont);
|
|
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:
|
|
s_HexEditData.pBuffer = (PBYTE) lParam;
|
|
s_HexEditData.cbBuffer = (int) wParam;
|
|
s_HexEditData.cbBufferMax = (int) wParam;
|
|
|
|
s_HexEditData.CaretIndex = 0;
|
|
s_HexEditData.MinimumSelectedIndex = 0;
|
|
s_HexEditData.MaximumSelectedIndex = 0;
|
|
|
|
s_HexEditData.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;
|
|
|
|
s_HexEditData.cbBuffer = 0;
|
|
|
|
// FEATURE: Do this symbolically...
|
|
s_HexEditData.Flags = 0;
|
|
|
|
s_HexEditData.cxWindow = 0;
|
|
s_HexEditData.cyWindow = 0;
|
|
|
|
hDC = GetDC(hWnd);
|
|
|
|
s_HexEditFont.lfHeight = -(10 * GetDeviceCaps(hDC, LOGPIXELSY) / 72);
|
|
|
|
if ((s_HexEditData.hFont = CreateFontIndirect(&s_HexEditFont)) != NULL)
|
|
{
|
|
hPrevFont = SelectObject(hDC, s_HexEditData.hFont);
|
|
GetTextMetrics(hDC, &TextMetric);
|
|
SelectObject(hDC, hPrevFont);
|
|
|
|
s_HexEditData.FontHeight = TextMetric.tmHeight;
|
|
|
|
s_HexEditData.LinesVisible = s_HexEditData.cyWindow / s_HexEditData.FontHeight;
|
|
|
|
s_HexEditData.FontMaxWidth = TextMetric.tmMaxCharWidth;
|
|
|
|
s_HexEditData.xHexDumpByteWidth = s_HexEditData.FontMaxWidth * 3;
|
|
s_HexEditData.xHexDumpStart = s_HexEditData.FontMaxWidth * 11 / 2;
|
|
s_HexEditData.xAsciiDumpStart = s_HexEditData.xHexDumpStart +
|
|
BYTES_PER_HEXEDIT_LINE * s_HexEditData.xHexDumpByteWidth +
|
|
s_HexEditData.FontMaxWidth * 3 / 2;
|
|
|
|
}
|
|
|
|
ReleaseDC(hWnd, hDC);
|
|
|
|
if (s_HexEditData.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
|
|
)
|
|
{
|
|
s_HexEditData.cxWindow = cx;
|
|
s_HexEditData.cyWindow = cy;
|
|
|
|
s_HexEditData.LinesVisible = cy / s_HexEditData.FontHeight;
|
|
|
|
HexEdit_SetScrollInfo(hWnd);
|
|
|
|
UNREFERENCED_PARAMETER(State);
|
|
UNREFERENCED_PARAMETER(cx);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* HexEdit_SetScrollInfo
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
VOID
|
|
PASCAL
|
|
HexEdit_SetScrollInfo(
|
|
HWND hWnd
|
|
)
|
|
{
|
|
SCROLLINFO ScrollInfo;
|
|
|
|
s_HexEditData.MaximumLines = (s_HexEditData.cbBuffer +
|
|
BYTES_PER_HEXEDIT_LINE) / BYTES_PER_HEXEDIT_LINE - 1;
|
|
|
|
ScrollInfo.cbSize = sizeof(ScrollInfo);
|
|
// DebugAssert(ScrollInfo.cbSize == sizeof(SCROLLINFO));
|
|
ScrollInfo.fMask = (SIF_RANGE | SIF_PAGE | SIF_POS);
|
|
ScrollInfo.nMin = 0;
|
|
ScrollInfo.nMax = s_HexEditData.MaximumLines;
|
|
ScrollInfo.nPage = s_HexEditData.LinesVisible;
|
|
ScrollInfo.nPos = s_HexEditData.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;
|
|
SCROLLINFO ScrollInfo;
|
|
|
|
NewFirstVisibleLine = s_HexEditData.FirstVisibleLine;
|
|
|
|
switch (Code)
|
|
{
|
|
case SB_LINEUP:
|
|
NewFirstVisibleLine--;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
NewFirstVisibleLine++;
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
NewFirstVisibleLine -= s_HexEditData.LinesVisible;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
NewFirstVisibleLine += s_HexEditData.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);
|
|
// DebugAssert(ScrollInfo.cbSize == sizeof(SCROLLINFO));
|
|
ScrollInfo.fMask = SIF_POS;
|
|
ScrollInfo.nPos = NewFirstVisibleLine;
|
|
|
|
NewFirstVisibleLine = SetScrollInfo(hWnd, SB_VERT, &ScrollInfo, TRUE);
|
|
|
|
if (s_HexEditData.FirstVisibleLine != NewFirstVisibleLine)
|
|
{
|
|
ScrollWindowEx(hWnd, 0, (s_HexEditData.FirstVisibleLine -
|
|
NewFirstVisibleLine) * s_HexEditData.FontHeight, NULL, NULL, NULL,
|
|
NULL, SW_INVALIDATE);
|
|
|
|
s_HexEditData.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(PaintStruct.hdc, &PaintStruct.rcPaint);
|
|
|
|
EndPaint(hWnd, &PaintStruct);
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* HexEdit_PaintRect
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
VOID
|
|
PASCAL
|
|
HexEdit_PaintRect(
|
|
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;
|
|
|
|
if (s_HexEditData.hFont)
|
|
hPrevFont = SelectFont(hDC, s_HexEditData.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 / s_HexEditData.FontHeight;
|
|
|
|
TextRect.bottom = CurrentLine * s_HexEditData.FontHeight;
|
|
AsciiTextRect.bottom = TextRect.bottom;
|
|
|
|
CurrentByteIndex = (s_HexEditData.FirstVisibleLine + CurrentLine) *
|
|
BYTES_PER_HEXEDIT_LINE;
|
|
|
|
LastLine = lpUpdateRect-> bottom / s_HexEditData.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 >= s_HexEditData.MaximumLines - s_HexEditData.FirstVisibleLine)
|
|
{
|
|
|
|
LastLine = s_HexEditData.MaximumLines - s_HexEditData.FirstVisibleLine;
|
|
|
|
BytesOnLastLine = s_HexEditData.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 += s_HexEditData.FontHeight;
|
|
|
|
TextRect.left = 0;
|
|
TextRect.right = s_HexEditData.xHexDumpStart;
|
|
|
|
x = TextRect.right + s_HexEditData.FontMaxWidth / 2;
|
|
|
|
StringCchPrintf(Buffer, ARRAYSIZE(Buffer), s_HexWordFormatSpec, CurrentByteIndex);
|
|
ExtTextOut(hDC, 0, TextRect.top, ETO_OPAQUE, &TextRect, Buffer, 4, NULL);
|
|
|
|
AsciiTextRect.top = AsciiTextRect.bottom;
|
|
AsciiTextRect.bottom += s_HexEditData.FontHeight;
|
|
AsciiTextRect.right = s_HexEditData.xAsciiDumpStart;
|
|
|
|
for (Counter = 0; Counter < BytesOnLine; Counter++, CurrentByteIndex++)
|
|
{
|
|
//
|
|
// Determine what colors to use to paint the current byte.
|
|
//
|
|
|
|
if (CurrentByteIndex >= s_HexEditData.MinimumSelectedIndex) {
|
|
|
|
if (CurrentByteIndex >= s_HexEditData.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 = s_HexEditData.pBuffer[CurrentByteIndex];
|
|
|
|
//
|
|
// Paint the hexadecimal representation.
|
|
//
|
|
|
|
TextRect.left = TextRect.right;
|
|
TextRect.right += s_HexEditData.xHexDumpByteWidth;
|
|
|
|
StringCchPrintf(Buffer, ARRAYSIZE(Buffer), s_HexByteFormatSpec, Byte);
|
|
|
|
ExtTextOut(hDC, x, TextRect.top, ETO_OPAQUE, &TextRect,
|
|
Buffer, 2, NULL);
|
|
|
|
x += s_HexEditData.xHexDumpByteWidth;
|
|
|
|
//
|
|
// Paint the ASCII representation.
|
|
//
|
|
|
|
AsciiTextRect.left = AsciiTextRect.right;
|
|
AsciiTextRect.right += s_HexEditData.FontMaxWidth;
|
|
|
|
Buffer[0] = (TCHAR) (((Byte & 0x7F) >= TEXT(' ')) ? Byte : TEXT('.'));
|
|
|
|
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 = s_HexEditData.xAsciiDumpStart;
|
|
|
|
ExtTextOut(hDC, TextRect.left, TextRect.top, ETO_OPAQUE, &TextRect,
|
|
NULL, 0, NULL);
|
|
|
|
AsciiTextRect.left = AsciiTextRect.right;
|
|
AsciiTextRect.right = s_HexEditData.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 = s_HexEditData.cxWindow;
|
|
TextRect.top = TextRect.bottom;
|
|
TextRect.bottom = lpUpdateRect-> bottom;
|
|
|
|
ExtTextOut(hDC, 0, TextRect.top, ETO_OPAQUE, &TextRect, NULL, 0, NULL);
|
|
}
|
|
|
|
if (s_HexEditData.hFont)
|
|
SelectFont(hDC, hPrevFont);
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* HexEdit_OnSetFocus
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
* hWnd, handle of HexEdit window.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
VOID
|
|
PASCAL
|
|
HexEdit_OnSetFocus(
|
|
HWND hWnd
|
|
)
|
|
{
|
|
s_HexEditData.Flags |= HEF_FOCUS;
|
|
|
|
CreateCaret(hWnd, NULL, 0, s_HexEditData.FontHeight);
|
|
HexEdit_SetCaretPosition(hWnd);
|
|
ShowCaret(hWnd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* HexEdit_OnKillFocus
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
* hWnd, handle of HexEdit window.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
VOID
|
|
PASCAL
|
|
HexEdit_OnKillFocus(
|
|
HWND hWnd
|
|
)
|
|
{
|
|
|
|
if (s_HexEditData.Flags & HEF_FOCUS) {
|
|
|
|
s_HexEditData.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
|
|
)
|
|
{
|
|
|
|
int NewCaretIndex;
|
|
|
|
if (fDoubleClick) {
|
|
|
|
HexEdit_ChangeCaretIndex(hWnd, s_HexEditData.CaretIndex + 1, TRUE);
|
|
return;
|
|
|
|
}
|
|
|
|
NewCaretIndex = HexEdit_HitTest(x, y);
|
|
|
|
HexEdit_ChangeCaretIndex(hWnd, NewCaretIndex, (KeyFlags & MK_SHIFT));
|
|
|
|
//
|
|
// If we don't already have the focus, try to get it.
|
|
//
|
|
|
|
if (!(s_HexEditData.Flags & HEF_FOCUS))
|
|
SetFocus(hWnd);
|
|
|
|
SetCapture(hWnd);
|
|
s_HexEditData.Flags |= HEF_DRAGGING;
|
|
|
|
s_HexEditData.xPrevMessagePos = x;
|
|
s_HexEditData.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
|
|
)
|
|
{
|
|
|
|
int NewCaretIndex;
|
|
|
|
if (!(s_HexEditData.Flags & HEF_DRAGGING))
|
|
return;
|
|
|
|
NewCaretIndex = HexEdit_HitTest(x, y);
|
|
|
|
HexEdit_ChangeCaretIndex(hWnd, NewCaretIndex, TRUE);
|
|
|
|
s_HexEditData.xPrevMessagePos = x;
|
|
s_HexEditData.yPrevMessagePos = y;
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
i = y < 0 ? -y : y - s_HexEditData.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
|
|
)
|
|
{
|
|
|
|
if (!(s_HexEditData.Flags & HEF_DRAGGING))
|
|
return;
|
|
|
|
KillTimer(hWnd, 1);
|
|
|
|
ReleaseCapture();
|
|
s_HexEditData.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(
|
|
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 >= s_HexEditData.cyWindow)
|
|
HitLine = s_HexEditData.LinesVisible + 1;
|
|
|
|
else
|
|
HitLine = y / s_HexEditData.FontHeight;
|
|
|
|
HitLine += s_HexEditData.FirstVisibleLine;
|
|
|
|
if (HitLine >= s_HexEditData.MaximumLines) {
|
|
|
|
HitLine = s_HexEditData.MaximumLines;
|
|
|
|
BytesOnHitLine = (s_HexEditData.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 < s_HexEditData.xHexDumpStart)
|
|
x = s_HexEditData.xHexDumpStart;
|
|
|
|
if (x >= s_HexEditData.xHexDumpStart && x <
|
|
s_HexEditData.xHexDumpStart + s_HexEditData.xHexDumpByteWidth *
|
|
BYTES_PER_HEXEDIT_LINE + s_HexEditData.FontMaxWidth) {
|
|
|
|
x -= s_HexEditData.xHexDumpStart;
|
|
|
|
HitByte = x / s_HexEditData.xHexDumpByteWidth;
|
|
|
|
s_HexEditData.Flags &= ~HEF_CARETINASCIIDUMP;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
HitByte = (x - (s_HexEditData.xAsciiDumpStart -
|
|
s_HexEditData.FontMaxWidth / 2)) / s_HexEditData.FontMaxWidth;
|
|
|
|
s_HexEditData.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.
|
|
//
|
|
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
|
|
if (HitByte >= BytesOnHitLine) {
|
|
|
|
if (BytesOnHitLine == BYTES_PER_HEXEDIT_LINE) {
|
|
|
|
HitByte = BYTES_PER_HEXEDIT_LINE;
|
|
s_HexEditData.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;
|
|
|
|
fControlDown = (GetKeyState(VK_CONTROL) < 0);
|
|
fShiftDown = (GetKeyState(VK_SHIFT) < 0);
|
|
|
|
NewCaretIndex = s_HexEditData.CaretIndex;
|
|
|
|
switch (VirtualKey) {
|
|
|
|
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 >
|
|
s_HexEditData.MaximumLines) {
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETATENDOFLINE)
|
|
goto onkey_MoveToEndOfBuffer;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto onkey_CheckUpperBound;
|
|
|
|
case VK_HOME:
|
|
if (fControlDown)
|
|
NewCaretIndex = 0;
|
|
|
|
else {
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETATENDOFLINE)
|
|
NewCaretIndex -= BYTES_PER_HEXEDIT_LINE;
|
|
|
|
else
|
|
NewCaretIndex &= (~BYTES_PER_HEXEDIT_LINE_MASK);
|
|
|
|
}
|
|
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
|
|
goto onkey_ChangeCaretIndex;
|
|
|
|
case VK_END:
|
|
if (fControlDown) {
|
|
|
|
onkey_MoveToEndOfBuffer:
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
NewCaretIndex = s_HexEditData.cbBuffer;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETATENDOFLINE)
|
|
break;
|
|
|
|
NewCaretIndex = (NewCaretIndex &
|
|
(~BYTES_PER_HEXEDIT_LINE_MASK)) + BYTES_PER_HEXEDIT_LINE;
|
|
|
|
if (NewCaretIndex > s_HexEditData.cbBuffer)
|
|
NewCaretIndex = s_HexEditData.cbBuffer;
|
|
|
|
else
|
|
s_HexEditData.Flags |= HEF_CARETATENDOFLINE;
|
|
|
|
}
|
|
|
|
goto onkey_ChangeCaretIndex;
|
|
|
|
case VK_PRIOR:
|
|
case VK_NEXT:
|
|
NewCaretIndex -= s_HexEditData.FirstVisibleLine *
|
|
BYTES_PER_HEXEDIT_LINE;
|
|
|
|
ScrollCode = ((VirtualKey == VK_PRIOR) ? SB_PAGEUP : SB_PAGEDOWN);
|
|
|
|
HexEdit_OnVScroll(hWnd, NULL, ScrollCode, 0);
|
|
|
|
NewCaretIndex += s_HexEditData.FirstVisibleLine *
|
|
BYTES_PER_HEXEDIT_LINE;
|
|
|
|
if (VirtualKey == VK_PRIOR)
|
|
goto onkey_CheckLowerBound;
|
|
|
|
else
|
|
goto onkey_CheckUpperBound;
|
|
|
|
case VK_LEFT:
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
NewCaretIndex--;
|
|
|
|
onkey_CheckLowerBound:
|
|
if (NewCaretIndex < 0)
|
|
break;
|
|
|
|
goto onkey_ChangeCaretIndex;
|
|
|
|
case VK_RIGHT:
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
NewCaretIndex++;
|
|
|
|
onkey_CheckUpperBound:
|
|
if (NewCaretIndex > s_HexEditData.cbBuffer)
|
|
NewCaretIndex = s_HexEditData.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;
|
|
BOOL fSuccess = TRUE;
|
|
|
|
//
|
|
// Check for any special control characters.
|
|
//
|
|
|
|
switch (Char) {
|
|
|
|
case IDKEY_COPY:
|
|
HexEdit_OnCopy(hWnd);
|
|
return;
|
|
|
|
case IDKEY_PASTE:
|
|
PrevCaretIndex = s_HexEditData.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;
|
|
|
|
}
|
|
|
|
//
|
|
// Validate and convert the typed character depending on the "column" the
|
|
// user is typing in.
|
|
//
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETINASCIIDUMP) {
|
|
|
|
if (Char < TEXT(' ')) {
|
|
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
|
|
}
|
|
|
|
NewCaretByte = (BYTE) Char;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Char = (CHAR) CharLower((LPTSTR) Char);
|
|
|
|
if (Char >= TEXT('0') && Char <= TEXT('9'))
|
|
NewCaretByte = (BYTE) (Char - TEXT('0'));
|
|
|
|
else if (Char >= TEXT('a') && Char <= TEXT('f'))
|
|
NewCaretByte = (BYTE) (Char - TEXT('a') + 10);
|
|
|
|
else {
|
|
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!(s_HexEditData.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 (s_HexEditData.MinimumSelectedIndex !=
|
|
s_HexEditData.MaximumSelectedIndex)
|
|
HexEdit_DeleteRange(hWnd, 0);
|
|
|
|
// Verify that we aren't overruning the value data buffer.
|
|
if (s_HexEditData.cbBuffer >= s_HexEditData.cbBufferMax)
|
|
{
|
|
// need a bigger buffer
|
|
PBYTE pbValueData = LocalReAlloc(s_HexEditData.pBuffer,
|
|
s_HexEditData.cbBuffer + ALLOCATION_INCR, LMEM_MOVEABLE);
|
|
|
|
if (pbValueData)
|
|
{
|
|
s_HexEditData.pBuffer = pbValueData;
|
|
s_HexEditData.cbBufferMax = s_HexEditData.cbBuffer + ALLOCATION_INCR;
|
|
}
|
|
else
|
|
{
|
|
InternalMessageBox(g_hInstance, hWnd, MAKEINTRESOURCE(IDS_EDITVALNOMEMORY),
|
|
MAKEINTRESOURCE(IDS_EDITVALERRORTITLE), MB_ICONERROR | MB_OK, NULL);
|
|
|
|
fSuccess = FALSE;
|
|
}
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
//
|
|
// Make room for the new byte by shifting all bytes after the insertion
|
|
// point down one byte.
|
|
//
|
|
|
|
pCaretByte = s_HexEditData.pBuffer + s_HexEditData.CaretIndex;
|
|
|
|
MoveMemory(pCaretByte + 1, pCaretByte, s_HexEditData.cbBuffer - s_HexEditData.CaretIndex);
|
|
|
|
s_HexEditData.cbBuffer++;
|
|
|
|
HexEdit_SetScrollInfo(hWnd);
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETINASCIIDUMP)
|
|
*pCaretByte = NewCaretByte;
|
|
|
|
else {
|
|
|
|
s_HexEditData.Flags |= HEF_INSERTATLOWNIBBLE;
|
|
|
|
*pCaretByte = NewCaretByte << 4;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
s_HexEditData.Flags &= ~HEF_INSERTATLOWNIBBLE;
|
|
|
|
*(s_HexEditData.pBuffer + s_HexEditData.CaretIndex) |= NewCaretByte;
|
|
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
|
|
PrevCaretIndex = s_HexEditData.CaretIndex;
|
|
|
|
if (!(s_HexEditData.Flags & HEF_INSERTATLOWNIBBLE)) {
|
|
|
|
s_HexEditData.CaretIndex++;
|
|
|
|
s_HexEditData.MinimumSelectedIndex = s_HexEditData.CaretIndex;
|
|
s_HexEditData.MaximumSelectedIndex = s_HexEditData.CaretIndex;
|
|
|
|
}
|
|
|
|
UpdateDisplay:
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
HexEdit_EnsureCaretVisible(hWnd);
|
|
|
|
UpdateRect.left = 0;
|
|
UpdateRect.right = s_HexEditData.cxWindow;
|
|
UpdateRect.top = (PrevCaretIndex / BYTES_PER_HEXEDIT_LINE -
|
|
s_HexEditData.FirstVisibleLine) * s_HexEditData.FontHeight;
|
|
UpdateRect.bottom = s_HexEditData.cyWindow;
|
|
|
|
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;
|
|
|
|
CaretByte = s_HexEditData.CaretIndex % BYTES_PER_HEXEDIT_LINE;
|
|
|
|
yCaret = (s_HexEditData.CaretIndex / BYTES_PER_HEXEDIT_LINE -
|
|
s_HexEditData.FirstVisibleLine) * s_HexEditData.FontHeight;
|
|
|
|
//
|
|
// Check if caret should really be displayed at the end of the previous
|
|
// line.
|
|
//
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETATENDOFLINE) {
|
|
|
|
CaretByte = BYTES_PER_HEXEDIT_LINE;
|
|
yCaret -= s_HexEditData.FontHeight;
|
|
|
|
}
|
|
|
|
//
|
|
// Figure out which "column" the user is editing in and thus should have
|
|
// the caret.
|
|
//
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETINASCIIDUMP) {
|
|
|
|
xCaret = s_HexEditData.xAsciiDumpStart + CaretByte *
|
|
s_HexEditData.FontMaxWidth;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
xCaret = s_HexEditData.xHexDumpStart + CaretByte *
|
|
s_HexEditData.xHexDumpByteWidth;
|
|
|
|
if (s_HexEditData.Flags & HEF_INSERTATLOWNIBBLE)
|
|
xCaret += s_HexEditData.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;
|
|
|
|
if (!(s_HexEditData.Flags & HEF_FOCUS))
|
|
return;
|
|
|
|
CaretLine = s_HexEditData.CaretIndex / BYTES_PER_HEXEDIT_LINE;
|
|
|
|
//
|
|
// Check if caret should really be displayed at the end of the previous
|
|
// line.
|
|
//
|
|
|
|
if (s_HexEditData.Flags & HEF_CARETATENDOFLINE)
|
|
CaretLine--;
|
|
|
|
LastVisibleLine = s_HexEditData.FirstVisibleLine +
|
|
s_HexEditData.LinesVisible - 1;
|
|
|
|
if (CaretLine > LastVisibleLine)
|
|
Delta = LastVisibleLine;
|
|
|
|
else if (CaretLine < s_HexEditData.FirstVisibleLine)
|
|
Delta = s_HexEditData.FirstVisibleLine;
|
|
|
|
else
|
|
Delta = -1;
|
|
|
|
if (Delta != -1) {
|
|
|
|
ScrollWindowEx(hWnd, 0, (Delta - CaretLine) * s_HexEditData.FontHeight,
|
|
NULL, NULL, NULL, NULL, SW_INVALIDATE);
|
|
|
|
s_HexEditData.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;
|
|
|
|
s_HexEditData.Flags &= ~HEF_INSERTATLOWNIBBLE;
|
|
|
|
PrevMinimumSelectedIndex = s_HexEditData.MinimumSelectedIndex;
|
|
PrevMaximumSelectedIndex = s_HexEditData.MaximumSelectedIndex;
|
|
|
|
if (fExtendSelection) {
|
|
|
|
if (s_HexEditData.CaretIndex == s_HexEditData.MaximumSelectedIndex)
|
|
s_HexEditData.MaximumSelectedIndex = NewCaretIndex;
|
|
|
|
else
|
|
s_HexEditData.MinimumSelectedIndex = NewCaretIndex;
|
|
|
|
if (s_HexEditData.MinimumSelectedIndex >
|
|
s_HexEditData.MaximumSelectedIndex) {
|
|
|
|
Swap = s_HexEditData.MinimumSelectedIndex;
|
|
s_HexEditData.MinimumSelectedIndex =
|
|
s_HexEditData.MaximumSelectedIndex;
|
|
s_HexEditData.MaximumSelectedIndex = Swap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
s_HexEditData.MinimumSelectedIndex = NewCaretIndex;
|
|
s_HexEditData.MaximumSelectedIndex = NewCaretIndex;
|
|
|
|
}
|
|
|
|
s_HexEditData.CaretIndex = NewCaretIndex;
|
|
|
|
UpdateRectCount = 0;
|
|
|
|
if (s_HexEditData.MinimumSelectedIndex > PrevMinimumSelectedIndex) {
|
|
|
|
UpdateRect[0].top = PrevMinimumSelectedIndex;
|
|
UpdateRect[0].bottom = s_HexEditData.MinimumSelectedIndex;
|
|
|
|
UpdateRectCount++;
|
|
|
|
}
|
|
|
|
else if (s_HexEditData.MinimumSelectedIndex < PrevMinimumSelectedIndex) {
|
|
|
|
UpdateRect[0].top = s_HexEditData.MinimumSelectedIndex;
|
|
UpdateRect[0].bottom = PrevMinimumSelectedIndex;
|
|
|
|
UpdateRectCount++;
|
|
|
|
}
|
|
|
|
if (s_HexEditData.MaximumSelectedIndex > PrevMaximumSelectedIndex) {
|
|
|
|
UpdateRect[UpdateRectCount].top = PrevMaximumSelectedIndex;
|
|
UpdateRect[UpdateRectCount].bottom = s_HexEditData.MaximumSelectedIndex;
|
|
|
|
UpdateRectCount++;
|
|
|
|
}
|
|
|
|
else if (s_HexEditData.MaximumSelectedIndex < PrevMaximumSelectedIndex) {
|
|
|
|
UpdateRect[UpdateRectCount].top = s_HexEditData.MaximumSelectedIndex;
|
|
UpdateRect[UpdateRectCount].bottom = PrevMaximumSelectedIndex;
|
|
|
|
UpdateRectCount++;
|
|
|
|
}
|
|
|
|
if (fPrevRangeEmpty = (PrevMinimumSelectedIndex ==
|
|
PrevMaximumSelectedIndex)) {
|
|
|
|
UpdateRect[0].top = s_HexEditData.MinimumSelectedIndex;
|
|
UpdateRect[0].bottom = s_HexEditData.MaximumSelectedIndex;
|
|
|
|
UpdateRectCount = 1;
|
|
|
|
}
|
|
|
|
if (s_HexEditData.MinimumSelectedIndex ==
|
|
s_HexEditData.MaximumSelectedIndex) {
|
|
|
|
if (!fPrevRangeEmpty) {
|
|
|
|
UpdateRect[0].top = PrevMinimumSelectedIndex;
|
|
UpdateRect[0].bottom = PrevMaximumSelectedIndex;
|
|
|
|
UpdateRectCount = 1;
|
|
|
|
}
|
|
|
|
else
|
|
UpdateRectCount = 0;
|
|
|
|
}
|
|
|
|
if (UpdateRectCount) {
|
|
|
|
HideCaret(hWnd);
|
|
|
|
hDC = GetDC(hWnd);
|
|
|
|
for (Index = 0; Index < UpdateRectCount; Index++) {
|
|
|
|
UpdateRect[Index].top = (UpdateRect[Index].top /
|
|
BYTES_PER_HEXEDIT_LINE - s_HexEditData.FirstVisibleLine) *
|
|
s_HexEditData.FontHeight;
|
|
UpdateRect[Index].bottom = (UpdateRect[Index].bottom /
|
|
BYTES_PER_HEXEDIT_LINE - s_HexEditData.FirstVisibleLine + 1) *
|
|
s_HexEditData.FontHeight;
|
|
|
|
if (UpdateRect[Index].top >= s_HexEditData.cyWindow ||
|
|
UpdateRect[Index].bottom < 0)
|
|
continue;
|
|
|
|
if (UpdateRect[Index].top < 0)
|
|
UpdateRect[Index].top = 0;
|
|
|
|
if (UpdateRect[Index].bottom > s_HexEditData.cyWindow)
|
|
UpdateRect[Index].bottom = s_HexEditData.cyWindow;
|
|
|
|
HexEdit_PaintRect(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;
|
|
|
|
s_HexEditData.Flags &= ~HEF_CARETATENDOFLINE;
|
|
|
|
MinimumSelectedIndex = s_HexEditData.MinimumSelectedIndex;
|
|
MaximumSelectedIndex = min(s_HexEditData.MaximumSelectedIndex, s_HexEditData.cbBuffer);
|
|
|
|
|
|
//
|
|
// 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 || s_HexEditData.Flags &
|
|
HEF_INSERTATLOWNIBBLE) {
|
|
|
|
s_HexEditData.Flags &= ~HEF_INSERTATLOWNIBBLE;
|
|
|
|
MaximumSelectedIndex++;
|
|
|
|
if (MaximumSelectedIndex > s_HexEditData.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 = s_HexEditData.pBuffer + MinimumSelectedIndex;
|
|
|
|
Length = MaximumSelectedIndex - MinimumSelectedIndex;
|
|
|
|
//
|
|
// Delete the bytes and update all appropriate window data.
|
|
//
|
|
|
|
MoveMemory(pMinimumSelectedByte, pMinimumSelectedByte + Length,
|
|
s_HexEditData.cbBuffer - MaximumSelectedIndex);
|
|
|
|
s_HexEditData.cbBuffer -= Length;
|
|
|
|
s_HexEditData.CaretIndex = MinimumSelectedIndex;
|
|
s_HexEditData.MinimumSelectedIndex = MinimumSelectedIndex;
|
|
s_HexEditData.MaximumSelectedIndex = MinimumSelectedIndex;
|
|
|
|
HexEdit_SetScrollInfo(hWnd);
|
|
|
|
// REARCHITECT: OnChar has the following same sequence!!!
|
|
HexEdit_EnsureCaretVisible(hWnd);
|
|
|
|
UpdateRect.left = 0;
|
|
UpdateRect.right = s_HexEditData.cxWindow;
|
|
UpdateRect.top = (MinimumSelectedIndex / BYTES_PER_HEXEDIT_LINE -
|
|
s_HexEditData.FirstVisibleLine) * s_HexEditData.FontHeight;
|
|
UpdateRect.bottom = s_HexEditData.cyWindow;
|
|
|
|
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;
|
|
|
|
fSuccess = FALSE;
|
|
|
|
cbClipboardData = s_HexEditData.MaximumSelectedIndex - s_HexEditData.MinimumSelectedIndex;
|
|
|
|
if (cbClipboardData != 0) {
|
|
|
|
lpStartByte = s_HexEditData.pBuffer + s_HexEditData.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 = FALSE;
|
|
HANDLE hClipboardData;
|
|
PBYTE pCaretByte;
|
|
|
|
if (s_HexEditData.Flags & HEF_INSERTATLOWNIBBLE)
|
|
{
|
|
|
|
s_HexEditData.Flags &= ~HEF_INSERTATLOWNIBBLE;
|
|
s_HexEditData.CaretIndex++;
|
|
|
|
}
|
|
|
|
if (OpenClipboard(hWnd))
|
|
{
|
|
if ((hClipboardData = GetClipboardData(s_HexEditClipboardFormat)) != NULL)
|
|
{
|
|
LPHEXEDITCLIPBOARDDATA lpClipboardData = (LPHEXEDITCLIPBOARDDATA) GlobalLock(hClipboardData);
|
|
|
|
if (lpClipboardData)
|
|
{
|
|
|
|
fSuccess = TRUE;
|
|
if (s_HexEditData.cbBuffer + (int)lpClipboardData-> cbSize > s_HexEditData.cbBufferMax)
|
|
{
|
|
// need a bigger buffer
|
|
PBYTE pbValueData = LocalReAlloc(s_HexEditData.pBuffer,
|
|
s_HexEditData.cbBuffer + lpClipboardData-> cbSize, LMEM_MOVEABLE);
|
|
|
|
if (pbValueData)
|
|
{
|
|
s_HexEditData.pBuffer = pbValueData;
|
|
s_HexEditData.cbBufferMax = s_HexEditData.cbBuffer + lpClipboardData-> cbSize;
|
|
}
|
|
else
|
|
{
|
|
InternalMessageBox(g_hInstance, hWnd, MAKEINTRESOURCE(IDS_EDITVALNOMEMORY),
|
|
MAKEINTRESOURCE(IDS_EDITVALERRORTITLE), MB_ICONERROR | MB_OK, NULL);
|
|
|
|
fSuccess = FALSE;
|
|
}
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
DWORD cbSize;
|
|
|
|
if (s_HexEditData.MinimumSelectedIndex !=
|
|
s_HexEditData.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 = s_HexEditData.pBuffer + s_HexEditData.CaretIndex;
|
|
cbSize = lpClipboardData->cbSize;
|
|
|
|
MoveMemory(pCaretByte + cbSize, pCaretByte,
|
|
s_HexEditData.cbBuffer - s_HexEditData.CaretIndex);
|
|
CopyMemory(pCaretByte, lpClipboardData-> Data, cbSize);
|
|
|
|
s_HexEditData.cbBuffer += cbSize;
|
|
s_HexEditData.CaretIndex += cbSize;
|
|
|
|
HexEdit_SetScrollInfo(hWnd);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
//
|
|
// Give us the focus if we don't already have it.
|
|
//
|
|
|
|
if (!(s_HexEditData.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 (s_HexEditData.MinimumSelectedIndex ==
|
|
s_HexEditData.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 (s_HexEditData.MinimumSelectedIndex == 0 &&
|
|
s_HexEditData.MaximumSelectedIndex == s_HexEditData.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:
|
|
s_HexEditData.MinimumSelectedIndex = 0;
|
|
s_HexEditData.MaximumSelectedIndex = s_HexEditData.cbBuffer;
|
|
s_HexEditData.CaretIndex = s_HexEditData.cbBuffer;
|
|
HexEdit_SetCaretPosition(hWnd);
|
|
InvalidateRect(hWnd, NULL, FALSE);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|