hexeditwnd.cpp

这是一个编辑器 这是一个编辑器

{
	// hook editbox'S
	HookHexEditbox( GetDlgItem(hDlg, SB_START) );
	HookHexEditbox( GetDlgItem(hDlg, SB_END) );
	HookHexEditbox( GetDlgItem(hDlg, SB_SIZE) );

	// limit text len
	SendDlgItemMessage(hDlg, SB_START, EM_SETLIMITTEXT, 8, 0);
	SendDlgItemMessage(hDlg, SB_END, EM_SETLIMITTEXT, 8, 0);
	SendDlgItemMessage(hDlg, SB_SIZE, EM_SETLIMITTEXT, 8, 0);

	return;
}

BOOL HexEditWnd::SBHandleWM_COMMAND(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	DWORD  dwStart, dwEnd;
	char   cBuff[9];
	BOOL   b;
	HWND   hESize, hEEnd;

	switch(LOWORD(wParam))
	{
	case SB_START:
	case SB_END:
	case SB_SIZE:
			if (HIWORD(wParam) != NM_HEXEDITENTER)
				return FALSE;
	case SB_OK:
		// get numbers
		GetDlgItemText(hDlg, SB_START, cBuff, sizeof(cBuff));
		HexStrToInt(cBuff, &dwStart);

		if (IsDlgButtonChecked(hDlg, SB_RADIOEND))
		{
			GetDlgItemText(hDlg, SB_END, cBuff, sizeof(cBuff));
			HexStrToInt(cBuff, &dwEnd);
		}
		else
		{
			GetDlgItemText(hDlg, SB_SIZE, cBuff, sizeof(cBuff));
			HexStrToInt(cBuff, &dwEnd);
			if (dwEnd != 0)
				--dwEnd;
			dwEnd += dwStart;
		}

		// valid?
		if (IsOutOfRange(dwEnd) ||
			IsOutOfRange(dwStart))
			ErrMsg(hDlg, "Out of range !");
		else
		{
			SetTopLine( (DWORD)__min(dwStart, dwEnd) );
			SetSelection(dwStart, dwEnd);
			SendMessage(hDlg, WM_CLOSE, 0, 0);
		}
		return TRUE;

	case SB_RADIOSIZE:
	case SB_RADIOEND:
		// GUI stuff
		hEEnd  = GetDlgItem(hDlg, SB_END);
		hESize = GetDlgItem(hDlg, SB_SIZE);
		b = (LOWORD(wParam) == SB_RADIOEND) ? TRUE : FALSE;
		EnableWindow( hEEnd, b);
		EnableWindow( hESize, b ^ 1);
		SetFocus( hEEnd );	
		SetWindowText( b ? hESize : hEEnd, "");
		SetFocus( b ? hEEnd : hESize);
		return TRUE;

	case SB_CANCEL:
		SendMessage(hDlg, WM_CLOSE, 0, 0);
		return TRUE;
	}

	return FALSE;
}

void HexEditWnd::SSInitDlg(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	HWND   hCur;
	char   cBuff[9];

	// setup str edit box
	HookEditboxEnter( GetDlgItem(hDlg, SS_STR) );

	// setup offset edit box
	hCur = GetDlgItem(hDlg, SS_OFFSET);
	HookHexEditbox(hCur);
	SendMessage(hCur, EM_SETLIMITTEXT, 8, 0);

	if (search.bInited)
	{
		//
		// restore last search options
		//

		// str stuff
		if (search.bASCIIStr)
			CheckDlgButton(hDlg, SS_SEARCHASCII, TRUE);
		if (search.bWideCharStr)
			CheckDlgButton(hDlg, SS_SEARCHUNICODE, TRUE);
		if (search.bCaseSensitive)
			CheckDlgButton(hDlg, SS_CASESENSITIVE, TRUE);
		else
			CheckDlgButton(hDlg, SS_NOCASESENSITIVE, TRUE);

		SetDlgItemText(hDlg, SS_STR, (PSTR)search.pDlgStr);

		/*
		if (search.bASCIIStr)
			SetDlgItemText(hDlg, SS_STR, (PSTR)search.pData);
		else if (search.bWideCharStr)
		{
			if (WideChar::WideToSingleCharStr((PWSTR)search.pData, (PSTR)search.pData, search.dwcBuff))
				SetDlgItemText(hDlg, SS_STR, (PSTR)search.pData);
		}
		else
		{
		}
		*/

		// location stuff
		if (search.bDown)
			CheckDlgButton(hDlg, SS_DOWN, TRUE);
		else
			CheckDlgButton(hDlg, SS_UP, TRUE);
		switch(search.iDlgSearchFrom)
		{
		case 0:
			CheckDlgButton(hDlg, SS_SEARCHFROMTOP, TRUE);
			break;

		case 1:
			if (stat.bCaretPosValid)
			{
				SendMessage(hDlg, WM_COMMAND, SS_SEARCHFROMCURPOS, 0);
				break;
			}
			// ...

		default: // 2 and eventually 1
			wsprintf(cBuff, H8, search.dwStartOff);
			SetDlgItemText(hDlg, SS_OFFSET, cBuff);
			CheckDlgButton(hDlg, SS_SEARCHFROMOFF, TRUE);			
			break;
		}

	}
	else
	{
		//
		// setup default dlg
		//

		// case sensitivity
		CheckDlgButton(hDlg, SS_NOCASESENSITIVE, TRUE);

		// set default settings
		CheckDlgButton(hDlg, SS_SEARCHASCII, TRUE);
		CheckDlgButton(hDlg, SS_SEARCHFROMTOP, TRUE);
		CheckDlgButton(hDlg, SS_DOWN, TRUE);
		if (!stat.bCaretPosValid)
		{
			// enable this radio
			EnableWindow( GetDlgItem(hDlg, SS_SEARCHFROMCURPOS), FALSE);
		}
	}

	// setup GUI
	SSEnableItems(hDlg);

	return;
}

BOOL HexEditWnd::SSHandleWM_COMMAND(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	char  cBuff[20];

	switch(LOWORD(wParam))
	{
	case SS_STR:
		if (HIWORD(wParam) != NM_HEXEDITENTER)
			return FALSE;
	case SS_OK:
		if (SSHandleSS_OK(hDlg))
		{
			SendMessage(hDlg, WM_CLOSE, 0, 0);
			PerformStrSearch(&search);
		}
		break;

	case SS_CANCEL:
		SendMessage(hDlg, WM_CLOSE, 0, 0);
		return TRUE;

	case SS_SEARCHASCII:
		CheckDlgButton(hDlg, SS_SEARCHUNICODE, BST_UNCHECKED);
		SSEnableItems(hDlg);
		return TRUE;

	case SS_SEARCHUNICODE:
		CheckDlgButton(hDlg, SS_SEARCHASCII, BST_UNCHECKED);
		SSEnableItems(hDlg);
		return TRUE;

	case SS_CASESENSITIVE:
	case SS_NOCASESENSITIVE:
		CheckRadioButton(hDlg, SS_CASESENSITIVE, SS_NOCASESENSITIVE, LOWORD(wParam) );
		return TRUE;

	case SS_SEARCHFROMCURPOS:
	case SS_SEARCHFROMTOP:
	case SS_SEARCHFROMOFF:
		CheckRadioButton(hDlg, SS_SEARCHFROMTOP, SS_SEARCHFROMOFF, LOWORD(wParam) );
		SSEnableItems(hDlg);

		// focus off editbox
		if (LOWORD(wParam) == SS_SEARCHFROMOFF)
			SetFocus( GetDlgItem(hDlg, SS_OFFSET) );

		// show current pos
		if (LOWORD(wParam) == SS_SEARCHFROMCURPOS)
		{
			// show current off
			wsprintf(cBuff, "("_H8")", stat.posCaret.dwOffset);
			SetDlgItemText(hDlg, SS_CUROFF, cBuff);
		}
		else
			SetDlgItemText(hDlg, SS_CUROFF, NULL);
		return TRUE;

	case SS_UP:
	case SS_DOWN:
		CheckRadioButton(hDlg, SS_DOWN, SS_UP, LOWORD(wParam) );
		return TRUE;
	}

	return FALSE; // ERR
}

void HexEditWnd::SSEnableItems(HWND hDlg)
{
	BOOL b;

	// case sensitive - radio
	b = IsDlgButtonChecked(hDlg, SS_SEARCHASCII) ||
		IsDlgButtonChecked(hDlg, SS_SEARCHUNICODE);
	EnableWindow( GetDlgItem(hDlg, SS_CASESENSITIVE), b);
	EnableWindow( GetDlgItem(hDlg, SS_NOCASESENSITIVE), b);

	// location
	b = IsDlgButtonChecked(hDlg, SS_SEARCHFROMOFF);
	EnableWindow( GetDlgItem(hDlg, SS_OFFSET), b);

	return;
}

//
// get search options from gui
//
BOOL HexEditWnd::SSHandleSS_OK(HWND hDlg)
{
	HWND               hStrEdit;
	HE_SEARCHOPTIONS   data;
	DWORD              dwByte, dwOff;
	char               cBuff[9];
	UINT               u;
	BOOL               bRet = FALSE;

	ZERO(data);

	//
	// handle search data
	//

	// get info
	hStrEdit = GetDlgItem(hDlg, SS_STR);
	data.dwcStr           = GetWindowTextLength(hStrEdit);
	data.bASCIIStr        = IsDlgButtonChecked(hDlg, SS_SEARCHASCII);
	data.bWideCharStr     = IsDlgButtonChecked(hDlg, SS_SEARCHUNICODE);
	data.bCaseSensitive   = IsDlgButtonChecked(hDlg, SS_CASESENSITIVE);

	// valid?
	if (!data.dwcStr)
	{
		ErrMsg(hDlg, "Please enter a search string !");
		goto Exit; // ERR
	}

	if ( !(data.bASCIIStr || data.bWideCharStr) &&
		 data.dwcStr % 2)
	{
		ErrMsg(hDlg, "Hex byte pairs have to result in an even number of digits !");
		goto Exit; // ERR
	}

	// get search str data
	data.dwcBuff = data.dwcStr + 1;
	if (data.bWideCharStr)
	{ 
		data.dwcBuff *= 2;
		data.dwcStr  *= 2;
	}
	data.pData   = malloc(data.dwcBuff);
	if (!data.pData)
	{
		ErrMsg(hDlg, STR_NO_MEM);
		goto Exit; // ERR
	}

	// save entered str
	data.pDlgStr = malloc(data.dwcStr + 1);
	if (!data.pDlgStr)
	{
		ErrMsg(hDlg, STR_NO_MEM);
		goto Exit; // ERR
	}
	GetDlgItemText(hDlg, SS_STR, (PSTR)data.pDlgStr, data.dwcStr + 1);

	// set search str data
	GetDlgItemText(hDlg, SS_STR, (PSTR)data.pData, data.dwcBuff);
	if ( !(data.bASCIIStr || data.bWideCharStr) )
	{
		// ASCII -> bytes
		data.dwcStr /= 2;
		for (u = 0; u < data.dwcStr; u++)
		{
			lstrcpyn(cBuff, (PSTR)((DWORD)data.pData + u * 2), 3);
			if (!HexStrToInt(cBuff, &dwByte))
			{
				ErrMsg(hDlg, "No hex string !");
				goto Exit; // ERR
			}
			*(BYTE*)((DWORD)data.pData + u) = (BYTE)dwByte;
		}
		
	}

	// finally convert ASCII -> UNICODE if wanted
	if (data.bWideCharStr)
		WideChar::SingleToWideCharStr(
			(PSTR)data.pData,
			(PWSTR)data.pData,
			data.dwcBuff);

	//
	// handle location
	//
	if (IsDlgButtonChecked(hDlg, SS_SEARCHFROMCURPOS))
	{
		data.dwStartOff       = stat.posCaret.dwOffset;
		data.iDlgSearchFrom   = 1;
	}
	else if (IsDlgButtonChecked(hDlg, SS_SEARCHFROMTOP))
	{
		data.dwStartOff      = 0;
		data.iDlgSearchFrom  = 0;
	}
	else
	{
		data.iDlgSearchFrom = 2;

		GetDlgItemText(hDlg, SS_OFFSET, cBuff, sizeof(cBuff));
		HexStrToInt(cBuff, &dwOff);
		if (IsOutOfRange(dwOff))
		{
			ErrMsg(hDlg, "Searching start offset is out of range !");
			goto Exit; // ERR
		}
		data.dwStartOff = dwOff;
	}
	data.bDown = IsDlgButtonChecked(hDlg, SS_DOWN);

	//
	// apply structure
	//

	// free old buffers
	if (search.bInited &&
		search.pData)
		free(search.pData);
	if (search.bInited &&
		search.pDlgStr)
		free(search.pDlgStr);

	search          = data;
	search.bInited  = TRUE;

	ConfigureTB();

	bRet = TRUE;

Exit:

	// free buffers
	if (!bRet && data.pData)
		free(data.pData);
	if (!bRet && data.pDlgStr)
		free(data.pDlgStr);

	return bRet; // OK
}

//
// searchs the stuff in the HE_SEARCHOPTIONS structure and setups the GUI
//
// returns:
// whether sth was found
//
//#pragma optimize("", off)
BOOL HexEditWnd::PerformStrSearch(PHE_SEARCHOPTIONS pso)
{
	DWORD   dwCurOff;
	BYTE*   pby;
	BOOL    bFound;

#define ERR_MSG(str) ErrMsg(hMainWnd, str, "Search Result:");

	if (!pso->bInited)
		return FALSE; // ERR

	// set status
	SetStatusText("Searching...");
	RepaintClientAreaNow();

	//
	// search
	//
	dwCurOff = pso->dwStartOff;

	// correct a too big off (when up search)
	if (!pso->bDown &&
		diData.dwSize - dwCurOff < pso->dwcStr)
		dwCurOff = diData.dwSize - pso->dwcStr;

	pby      = (BYTE*)((DWORD)diData.pDataBuff + dwCurOff);
	bFound   = FALSE;

	if (pso->bASCIIStr || pso->bWideCharStr)
	{
		//
		// non-case sensitive ASCII/UNICODE string search
		//
		if (!pso->bCaseSensitive)
		{
			if ( pso->bASCIIStr )
			{
				// ascii
				if (pso->bDown) // ...down
					while (dwCurOff + pso->dwcStr <= diData.dwSize)
					{
						if (!strnicmp((PCSTR)pso->pData, (PCSTR)pby, pso->dwcStr))
						{
							bFound = TRUE;
							break;
						}
						++dwCurOff;
						++pby;
					}
				else // ...up
					while (dwCurOff != (DWORD)-1)
					{
						if (!strnicmp((PCSTR)pso->pData, (PCSTR)pby, pso->dwcStr))
						{
							bFound = TRUE;
							break;
						}
						--dwCurOff;
						--pby;
					}
			}
			else
			{
				// unicode
				if (pso->bDown) // ...down
					while (dwCurOff + pso->dwcStr <= diData.dwSize)
					{
						if ( !wcsnicmp((LPWSTR)pso->pData, (LPWSTR)pby, pso->dwcStr/2) )
						{
							bFound = TRUE;
							break;
						}
						++dwCurOff;
						++pby;
					}
				else // ...up
					while (dwCurOff != (DWORD)-1)
					{
						if ( !wcsnicmp((LPWSTR)pso->pData, (LPWSTR)pby, pso->dwcStr/2) )
						{
							bFound = TRUE;
							break;
						}
						--dwCurOff;
						--pby;
					}
			}
		}
		//
		// case sensitive ASCII/UNICODE string search
		//
		else
		{
			if (pso->bDown) // ..down
				while (dwCurOff + pso->dwcStr <= diData.dwSize)
				{
					if (!memcmp(pso->pData, pby, pso->dwcStr))
					{
						bFound = TRUE;
						break;
					}
					++dwCurOff;
					++pby;
				}
			else // ...up
				while (dwCurOff != -1)
				{
					if (!memcmp(pso->pData, pby, pso->dwcStr))
					{
						bFound = TRUE;
						break;
					}
					--dwCurOff;
					--pby;
				}
		}
	}
	else
	{
		//
		// byte search
		//
		if (pso->bDown) // ...down
			while (dwCurOff + pso->dwcStr <= diData.dwSize)
			{
				if (!memcmp(pso->pData, pby, pso->dwcStr))
				{
					bFound = TRUE;
					break;
				}
				++dwCurOff;
				++pby;
			}
		else
			while (dwCurOff != -1)
			{
				if (dwCurOff == 0x10)
					__asm NOP
				if (!memcmp(pso->pData, pby, pso->dwcStr))
				{
					bFound = TRUE;
					break;
				}
				--dwCurOff;
				--pby;
			}

	}

	//
	// mark found area
	//
	if (bFound)
	{
		// save match off
		//search.dwLastFoundOff = dwCurOff;

		// setup GUI
		SetSelection(dwCurOff, dwCurOff + pso->dwcStr - 1);
		if (!IsOffsetVisible(dwCurOff))
			SetTopLine(dwCurOff);
	}
	else
	{
		ERR_MSG(pso->bDown ? "Buffer end reached." : "Buffer start reached.");
	}

	// refresh status
	SetCaretSelInfoToStatus();
	RepaintClientArea();

	return bFound;

#undef ERR_MSG
}
//#pragma optimize("", on)

BOOL HexEditWnd::PerformSearchAgain(PHE_SEARCHOPTIONS pso, BOOL bDown)
{
	// valid?
	if (!pso->bInited)
		return FALSE; // ERR

	if (!stat.bCaretPosValid)
	{
		ErrMsg("Caret to set !");
		return FALSE; // ERR
	}
	
	// mod HE_SEARCHOPTIONS struct
	// (bad offsets are catched by "PerformStrSearch")
	if (bDown)
	{
		if (stat.bSel)
			pso->dwStartOff = stat.dwOffSelEnd + 1;
		else
			pso->dwStartOff = stat.posCaret.dwOffset;
	}
	else
	{
		if (stat.bSel)
			pso->dwStartOff = stat.dwOffSelStart - 1;
		else
			pso->dwStartOff = stat.posCaret.dwOffset;
	}
	pso->bDown = bDown;

	return PerformStrSearch(pso);
}

BOOL HexEditWnd::CopySelectedBlock()
{
	HANDLE               hMem;
	void                 *pMe