开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTHexEdit.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：41k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTHexEdit.cpp：源码内容
  1. // XTHexEdit.cpp : implementation of the CXTHexEdit class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Resource.h"
  25. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  26. #include "Common/XTPResourceManager.h"
  27. #include "Common/XTPColorManager.h"
  28. #include "Common/XTPDrawHelpers.h"
  30. #include "XTFunctions.h"
  31. #include "XTHexEdit.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. static const CLIPFORMAT CF_BINARY = (CLIPFORMAT)
  40. ::RegisterClipboardFormat(_T("BinaryData"));
  42. static const BYTE chHexTable[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  43. #define TOHEX(a, b) {*b++ = chHexTable[a >> 4]; *b++ = chHexTable[a & 0xf];}
  45. /////////////////////////////////////////////////////////////////////////////
  46. // CXTHexEdit
  47. /////////////////////////////////////////////////////////////////////////////
  48. CXTHexEdit::CXTHexEdit()
  49. {
  50. m_pData = NULL;
  51. m_nLength = 0;
  52. m_nTopIndex = 0;
  53. m_nCurrentAddress = 0;
  54. m_nSelStart = -1;
  55. m_nSelEnd = -1;
  56. m_nBytePerRow = 8;
  57. m_bDynamicBPR = FALSE;
  58. m_nLinesPerPage = 1;
  59. m_nLineHeight = 0;
  60. m_nNullWidth = 0;
  61. m_nOffHex = 0;
  62. m_nOffAscii = 0;
  63. m_nOffAddress = 0;
  64. m_bShowHex = TRUE;
  65. m_bShowAscii = TRUE;
  66. m_bShowAddress = TRUE;
  67. m_bAddressIsWide = TRUE;
  68. m_bShowCaret = TRUE;
  69. m_bUpdate = TRUE;
  70. m_bAllowDeletes = true;
  71. m_ptEditPos.x = 0;
  72. m_ptEditPos.y = 0;
  73. m_eEditMode = editNone;
  74. m_szCaret = CSize(0, 0);
  75. m_crBack = GetXtremeColor(COLOR_WINDOW);
  76. m_crText = GetXtremeColor(COLOR_WINDOWTEXT);
  77. m_crDisabledBack = GetXtremeColor(COLOR_3DFACE);
  78. m_crDisabledText = GetXtremeColor(COLOR_GRAYTEXT);
  79. m_crHighlightBack = GetXtremeColor(COLOR_HIGHLIGHT);
  80. m_crHighlightText = GetXtremeColor(COLOR_HIGHLIGHTTEXT);
  81. m_crDisabledHighlightText = GetXtremeColor(COLOR_HIGHLIGHTTEXT);
  82. m_crDisabledHighlightBack = GetXtremeColor(COLOR_3DSHADOW);
  84. m_nMaxLength = 0;
  85. m_dwBaseAddress = 0;
  87. _AFX_THREAD_STATE* pState = AfxGetThreadState();
  88. if (!pState->m_bNeedTerm)
  89. {
  90. AfxOleInit();
  91. }
  93. // create the default font used by the hex edit control.
  94. m_fontHex.CreateFont(-12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _T("Courier New"));
  95. }
  97. CXTHexEdit::~CXTHexEdit()
  98. {
  99. if (m_fontHex.GetSafeHandle())
  100. m_fontHex.DeleteObject();
  102. if (m_pData)
  103. {
  104. free(m_pData);
  105. m_pData = NULL;
  106. }
  107. }
  109. IMPLEMENT_DYNAMIC(CXTHexEdit, CWnd)
  111. BEGIN_MESSAGE_MAP(CXTHexEdit, CXTHexEditBase)
  112. //{{AFX_MSG_MAP(CXTHexEdit)
  113. ON_WM_CHAR()
  114. ON_WM_KILLFOCUS()
  115. ON_WM_PAINT()
  116. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  117. ON_WM_SETFOCUS()
  118. ON_WM_SIZE()
  119. ON_WM_VSCROLL()
  120. ON_WM_HSCROLL()
  121. ON_WM_GETDLGCODE()
  122. ON_WM_ERASEBKGND()
  123. ON_WM_LBUTTONDOWN()
  124. ON_WM_LBUTTONDBLCLK()
  125. ON_WM_MOUSEMOVE()
  126. ON_WM_LBUTTONUP()
  127. ON_WM_KEYDOWN()
  128. ON_WM_CONTEXTMENU()
  129. ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
  130. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  131. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  132. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  133. ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
  134. ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
  135. ON_WM_NCPAINT()
  136. ON_WM_MOUSEWHEEL()
  137. //}}AFX_MSG_MAP
  138. END_MESSAGE_MAP()
  140. void CXTHexEdit::RestoreDefaultFont()
  141. {
  142. if (m_fontHex.GetSafeHandle())
  143. m_fontHex.DeleteObject();
  145. // create the default font used by the hex edit control.
  146. m_fontHex.CreateFont(-12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _T("Courier New"));
  147. }
  149. void CXTHexEdit::SetHexFont(CFont* pFont)
  150. {
  151. ASSERT(pFont->GetSafeHandle());
  153. if (pFont->GetSafeHandle())
  154. {
  155. LOGFONT lf;
  156. pFont->GetLogFont(&lf);
  157. SetHexFont(&lf);
  158. }
  159. }
  161. void CXTHexEdit::SetHexFont(LOGFONT* pLogFont)
  162. {
  163. ASSERT(pLogFont != NULL);
  165. if (m_fontHex.GetSafeHandle())
  166. m_fontHex.DeleteObject();
  168. m_fontHex.CreateFontIndirect(pLogFont);
  169. }
  171. COLORREF CXTHexEdit::GetActualBackColor()
  172. {
  173. if (IsReadOnly())
  174. {
  175. return m_crDisabledBack;
  176. }
  178. return m_crBack;
  179. }
  181. COLORREF CXTHexEdit::GetActualTextColor()
  182. {
  183. if (!IsWindowEnabled())
  184. {
  185. return m_crDisabledText;
  186. }
  188. return m_crText;
  189. }
  191. COLORREF CXTHexEdit::GetActualHighlightBackColor()
  192. {
  193. if (!IsWindowEnabled())
  194. {
  195. return m_crDisabledHighlightBack;
  196. }
  198. return m_crHighlightBack;
  199. }
  201. COLORREF CXTHexEdit::GetActualHighlightTextColor()
  202. {
  203. if (!IsWindowEnabled())
  204. {
  205. return m_crDisabledHighlightText;
  206. }
  208. return m_crHighlightText;
  209. }
  211. void CXTHexEdit::OnPaint()
  212. {
  213. CPaintDC dc(this);
  215. // Paint to a memory device context to help
  216. // eliminate screen flicker.
  217. CXTPBufferDC memDC(dc);
  219. OnDraw(&memDC);
  220. }
  222. LRESULT CXTHexEdit::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  223. {
  224. CDC* pDC = CDC::FromHandle((HDC)wParam);
  225. if (pDC)
  226. {
  227. OnDraw(pDC);
  228. }
  229. return 1;
  230. }
  232. void CXTHexEdit::OnDraw(CDC* pDC)
  233. {
  234. // Get the client rect.
  235. CXTPClientRect rectClient(this);
  237. pDC->FillSolidRect(rectClient, GetActualBackColor());
  239. // Save the current device context, we will restore this just
  240. // before we loose scope.
  241. int nSavedDC = pDC->SaveDC();
  243. ASSERT(m_nCurrentAddress >= 0);
  244. ASSERT(m_nTopIndex >= 0);
  246. pDC->SelectObject(&m_fontHex);
  248. int height = 0;
  249. int x = rectClient.TopLeft().x;
  250. int y = rectClient.TopLeft().y;
  252. TCHAR buf[256];
  254. pDC->SetBoundsRect(&rectClient, DCB_DISABLE);
  255. pDC->SetTextColor(GetActualTextColor());
  257. // Get char dimensions
  258. if (m_bUpdate)
  259. {
  260. const int h_delta = ::GetScrollPos(m_hWnd, SB_HORZ) * m_nNullWidth;
  262. pDC->GetCharWidth('0', '0', &m_nNullWidth);
  263. CSize sz = pDC->GetTextExtent(_T("0"), 1);
  264. m_nLineHeight = sz.cy;
  266. const int width_address = (m_bAddressIsWide ? 9 : 5) * m_nNullWidth;
  267. m_nOffHex = m_bShowAddress ? width_address : 0;
  269. m_nOffAscii = m_nOffHex;
  270. if (m_bShowHex) m_nOffAscii += m_nBytePerRow * 3 * m_nNullWidth;
  272. m_nOffAddress = -h_delta;
  273. m_nOffHex -= h_delta;
  274. m_nOffAscii -= h_delta;
  276. m_nLinesPerPage = rectClient.Height() / m_nLineHeight;
  277. m_bUpdate = FALSE;
  278. UpdateScrollbars();
  279. }
  281. if (m_pData)
  282. {
  283. height = rectClient.Height() / m_nLineHeight;
  284. height *= m_nLineHeight;
  286. if (m_bShowAddress)
  287. {
  288. y = 0;
  289. CRect rcd = rectClient;
  290. rcd.left = m_nOffAddress;
  292. // draw address
  293. int i;
  294. for (i = m_nTopIndex;
  295. (i < (m_nLength + 1)) && (rcd.TopLeft().y < height);
  296. i += m_nBytePerRow)
  297. {
  298. const int width = m_bAddressIsWide ? 8 : 4;
  300. #if (_MSC_VER > 1310) // VS2005
  301. _stprintf_s(buf, _countof(buf),  _T("%0*lX"), width, m_dwBaseAddress + i);
  302. #else
  303. _stprintf(buf, _T("%0*lX"), width, m_dwBaseAddress + i);
  304. #endif
  305. pDC->DrawText(buf, width, rcd,
  306. DT_LEFT | DT_TOP | DT_SINGLELINE | DT_NOPREFIX);
  307. rcd.TopLeft().y += m_nLineHeight;
  308. }
  309. }
  310. if (m_bShowHex)
  311. {
  312. y = 0;
  313. CRect rcd = rectClient;
  314. rcd.left = x = m_nOffHex;
  316. if (m_nSelStart != -1 && (m_eEditMode == editHigh || m_eEditMode == editLow))
  317. {
  318. int  i;
  319. int  n = 0;
  320. int  selStart, selEnd;
  321. GetSel(selStart, selEnd);
  323. for (i = m_nTopIndex; (i < selStart) && (y < height); i++)
  324. {
  325. LPTSTR p = &buf[0];
  327. TOHEX(m_pData[i], p);
  329. *p++ = ' ';
  330. pDC->TextOut(x, y, buf, 3);
  331. x += m_nNullWidth * 3;
  332. n++;
  333. if (n == m_nBytePerRow)
  334. {
  335. n = 0;
  336. x = m_nOffHex;
  337. y += m_nLineHeight;
  338. }
  339. }
  341. pDC->SetTextColor(GetActualHighlightTextColor());
  342. pDC->SetBkColor(GetActualHighlightBackColor());
  343. for (; (i < selEnd) && (i < m_nLength) && (y < height); i++)
  344. {
  345. LPTSTR p = &buf[0];
  347. TOHEX(m_pData[i], p);
  349. *p++ = ' ';
  350. pDC->TextOut(x, y, buf, 3);
  351. x += m_nNullWidth * 3;
  352. n++;
  353. if (n == m_nBytePerRow)
  354. {
  355. n = 0;
  356. x = m_nOffHex;
  357. y += m_nLineHeight;
  358. }
  359. }
  360. pDC->SetTextColor(GetActualTextColor());
  361. pDC->SetBkColor(GetActualBackColor());
  362. for (; (i < m_nLength) && (y < height); i++)
  363. {
  364. LPTSTR p = &buf[0];
  366. TOHEX(m_pData[i], p);
  368. *p++ = ' ';
  369. pDC->TextOut(x, y, buf, 3);
  370. x += m_nNullWidth * 3;
  371. n++;
  372. if (n == m_nBytePerRow)
  373. {
  374. n = 0;
  375. x = m_nOffHex;
  376. y += m_nLineHeight;
  377. }
  378. }
  379. }
  380. else
  381. {
  382. int i;
  383. for (i = m_nTopIndex; (i < m_nLength) && (rcd.TopLeft().y < height);)
  384. {
  385. LPTSTR p = &buf[0];
  387. int n;
  388. for (n = 0; (n < m_nBytePerRow) && (i < m_nLength); n++)
  389. {
  390. TOHEX(m_pData[i], p);
  391. *p++ = ' ';
  392. i++;
  393. }
  395. while (n < m_nBytePerRow)
  396. {
  397. *p++ = ' ';
  398. *p++ = ' ';
  399. *p++ = ' ';
  400. n++;
  401. }
  403. pDC->DrawText(buf, m_nBytePerRow * 3, rcd, DT_LEFT | DT_TOP | DT_SINGLELINE | DT_NOPREFIX);
  404. rcd.TopLeft().y += m_nLineHeight;
  405. }
  406. }
  407. }
  408. if (m_bShowAscii)
  409. {
  410. y = 0;
  411. CRect rcd = rectClient;
  412. rcd.left = x = m_nOffAscii;
  413. if (m_nSelStart != -1 && m_eEditMode == editAscii)
  414. {
  415. int  i;
  416. int  n = 0;
  417. int  selStart, selEnd;
  418. GetSel(selStart, selEnd);
  420. for (i = m_nTopIndex; (i < selStart) && (y < height); i++)
  421. {
  422. buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
  423. pDC->TextOut(x, y, buf, 1);
  424. x += m_nNullWidth;
  425. n++;
  426. if (n == m_nBytePerRow)
  427. {
  428. n = 0;
  429. x = m_nOffAscii;
  430. y += m_nLineHeight;
  431. }
  432. }
  433. pDC->SetTextColor(GetActualHighlightTextColor());
  434. pDC->SetBkColor(GetActualHighlightBackColor());
  435. for (; (i < selEnd) && (y < height); i++)
  436. {
  437. buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
  438. pDC->TextOut(x, y, buf, 1);
  439. x += m_nNullWidth;
  440. n++;
  441. if (n == m_nBytePerRow)
  442. {
  443. n = 0;
  444. x = m_nOffAscii;
  445. y += m_nLineHeight;
  446. }
  447. }
  448. pDC->SetTextColor(GetActualTextColor());
  449. pDC->SetBkColor(GetActualBackColor());
  450. for (; (i < m_nLength) && y < height; i++)
  451. {
  452. buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
  453. pDC->TextOut(x, y, buf, 1);
  454. x += m_nNullWidth;
  455. n++;
  456. if (n == m_nBytePerRow)
  457. {
  458. n = 0;
  459. x = m_nOffAscii;
  460. y += m_nLineHeight;
  461. }
  462. }
  463. }
  464. else
  465. {
  466. int i;
  467. for (i = m_nTopIndex; (i < m_nLength) && (rcd.top < height);)
  468. {
  469. LPTSTR p = &buf[0];
  471. int n;
  472. for (n = 0; (n < m_nBytePerRow) && (i < m_nLength); n++)
  473. {
  474. *p++ = isprint(m_pData[i]) ? m_pData[i] : '.';
  475. i++;
  476. }
  478. pDC->DrawText(buf, n, rcd, DT_LEFT | DT_TOP | DT_SINGLELINE | DT_NOPREFIX);
  479. rcd.top += m_nLineHeight;
  480. }
  481. }
  482. }
  483. }
  485. // Restore the device context.
  486. pDC->RestoreDC(nSavedDC);
  487. }
  489. void CXTHexEdit::OnSetFocus(CWnd* pOldWnd)
  490. {
  491. CXTHexEditBase::OnSetFocus(pOldWnd);
  492. if (m_pData && !IsSelected())
  493. {
  494. if (m_ptEditPos.x == 0 && m_bShowAddress)
  495. {
  496. CreateAddressCaret();
  497. }
  498. else
  499. {
  500. CreateEditCaret();
  501. }
  502. RepositionCaret(m_nCurrentAddress);
  503. }
  504. }
  506. void CXTHexEdit::OnKillFocus(CWnd* pNewWnd)
  507. {
  508. DestroyCaret();
  509. CXTHexEditBase::OnKillFocus(pNewWnd);
  510. }
  512. void CXTHexEdit::OnVScroll(UINT nSBCode, UINT /*nPos*/, CScrollBar* /*pScrollBar*/)
  513. {
  514. DoVScroll(nSBCode, false);
  515. }
  517. void CXTHexEdit::DoVScroll(UINT nSBCode, bool bMoveCaret)
  518. {
  519. if (!m_pData)
  520. {
  521. return;
  522. }
  524. BOOL bVisible = GetStyle() & WS_VISIBLE;
  526. // Turn off redraw while scrolling, this will cause paint problems
  527. // with our control because we are painting off screen to reduce
  528. // flicker.  The default implementation assumes that WM_ERASEBKGND
  529. // has repainted the background, which in our case does not happen.
  531. if (bVisible) SetRedraw(FALSE);
  533. const int oa = m_nTopIndex;
  534. SCROLLINFO  si;
  535. ZeroMemory(&si, sizeof(SCROLLINFO));
  536. si.cbSize = sizeof(SCROLLINFO);
  537. si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
  538. if (GetStyle() & WS_VSCROLL)
  539. {
  540. VERIFY(::GetScrollInfo(m_hWnd, SB_VERT, &si));
  541. }
  542. else
  543. {
  544. si.nPage = si.nPos = si.nMin = si.nMax = 0;
  545. }
  547. switch (nSBCode)
  548. {
  549. case SB_LINEDOWN:
  550. if (si.nPos < (si.nMax - (int)si.nPage + 1))
  551. {
  552. m_nTopIndex += m_nBytePerRow;
  553. }
  554. break;
  556. case SB_LINEUP:
  557. if (m_nTopIndex > 0)
  558. {
  559. m_nTopIndex -= m_nBytePerRow;
  560. if (m_nTopIndex < 0) m_nTopIndex = 0;
  561. }
  562. break;
  564. case SB_PAGEDOWN:
  565. si.nPos += si.nPage;
  566. if (si.nPos >= si.nMax) si.nPos = si.nMax;
  567. m_nTopIndex = si.nPos * m_nBytePerRow;
  568. break;
  570. case SB_PAGEUP:
  571. if (oa == 0)
  572. {
  573. m_nCurrentAddress = 0;
  574. }
  575. else
  576. {
  577. m_nTopIndex -= m_nBytePerRow * m_nLinesPerPage;
  578. if (m_nTopIndex < 0)
  579. m_nTopIndex = 0;
  580. }
  581. break;
  583. case SB_THUMBTRACK:
  584. si.fMask = SIF_TRACKPOS;
  586. // Call GetScrollInfo to get current tracking
  587. // position in si.nTrackPos
  589. if (!::GetScrollInfo(m_hWnd, SB_VERT, &si))
  590. {
  591. return ; // GetScrollInfo failed
  592. }
  594. m_nTopIndex = si.nTrackPos * m_nBytePerRow;
  595. break;
  596. }
  598. if (bMoveCaret)
  599. {
  600. m_nCurrentAddress += (m_nTopIndex - oa);
  601. }
  603. // bug fix by John M. Drescher jdrescher@geocities.com
  604. if (m_nCurrentAddress < 0)
  605. {
  606. m_nCurrentAddress = 0;
  607. }
  609. UpdateScrollbars();
  610. RepositionCaret(m_nCurrentAddress);
  612. if (bVisible) SetRedraw(TRUE);
  614. // repaint the list box
  615. Invalidate();
  616. UpdateWindow();
  618. // repaint the scroll bar.
  619. ::SetWindowPos(m_hWnd, NULL, 0, 0, 0, 0,
  620. SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
  621. }
  623. BOOL CXTHexEdit::PreCreateWindow(CREATESTRUCT& cs)
  624. {
  625. if (!CXTHexEditBase::PreCreateWindow(cs))
  626. return FALSE;
  628. return TRUE;
  629. }
  631. BOOL CXTHexEdit::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  632. {
  633. return Create(_T("EDIT"), 0, dwStyle, rect, pParentWnd, nID);
  634. }
  636. BOOL CXTHexEdit::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
  637. {
  638. if (!CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext))
  639. {
  640. TRACE0("Failed to create hex edit control.n");
  641. return FALSE;
  642. }
  644. CWnd::SetFont(&m_fontHex);
  646. return TRUE;
  647. }
  649. BOOL CXTHexEdit::OnEraseBkgnd(CDC* /*pDC*/)
  650. {
  651. return TRUE;
  652. }
  654. void CXTHexEdit::OnLButtonDown(UINT nFlags, CPoint point)
  655. {
  656. SetFocus();
  657. if (!m_pData)
  658. {
  659. return;
  660. }
  662. if (nFlags & MK_SHIFT)
  663. {
  664. m_nSelStart = m_nCurrentAddress;
  665. }
  666. CPoint pt = CalcPos(point.x, point.y);
  667. if (pt.x > -1)
  668. {
  669. m_ptEditPos = pt;
  670. pt.x *= m_nNullWidth;
  671. pt.y *= m_nLineHeight;
  673. if (pt.x == 0 && m_bShowAddress)
  674. {
  675. CreateAddressCaret();
  676. }
  677. else
  678. {
  679. CreateEditCaret();
  680. }
  682. SetCaretPos(pt);
  683. if (nFlags & MK_SHIFT)
  684. {
  685. m_nSelEnd = m_nCurrentAddress;
  686. if (m_eEditMode == editHigh || m_eEditMode == editLow)
  687. {
  688. m_nSelEnd++;
  689. }
  690. RedrawWindow();
  691. }
  692. }
  693. if (!(nFlags & MK_SHIFT))
  694. {
  695. if (::DragDetect(m_hWnd, point))
  696. {
  697. m_nSelStart = m_nCurrentAddress;
  698. m_nSelEnd = m_nSelStart;
  699. SetCapture();
  700. }
  701. else
  702. {
  703. BOOL bsel = m_nSelStart != -1;
  705. m_nSelStart = -1;
  706. m_nSelEnd = -1;
  707. if (bsel)
  708. {
  709. RedrawWindow();
  710. }
  711. }
  712. }
  713. if (!IsSelected())
  714. {
  715. if (m_bShowCaret)
  716. ShowCaret();
  717. }
  718. }
  720. // in: pixels
  721. // out: character coordinates + change of m_nCurrrentAddress
  722. CPoint CXTHexEdit::CalcPos(int x, int y)
  723. {
  724. if (y < 0 || x < 0)
  725. return CPoint(-1, -1);
  727. int lastVisRow = m_nLength / m_nBytePerRow - (m_nTopIndex / m_nBytePerRow);
  728. int row = y / m_nLineHeight;
  729. y = row + (m_nTopIndex / m_nBytePerRow);
  732. //  x += (m_nNullWidth - 1);
  733. x /= m_nNullWidth;
  735. //In address area
  736. const int right_of_address = (m_nOffAddress / m_nNullWidth) + // one past last
  737. (!m_bShowAddress ? -1 : (m_bAddressIsWide ? 8 : 4));
  738. if (x < right_of_address)
  739. {
  740. //Set first byte in line as current.
  741. m_nCurrentAddress = m_nTopIndex + (m_nBytePerRow * row);
  742. m_eEditMode = editNone;
  743. return CPoint(0, row);
  744. }
  746. //In hex area
  747. const int right_of_hex_area = right_of_address +
  748. (!m_bShowHex ? 0 : (m_nBytePerRow * 3)); //3 = 3 chars per byte (e.g. cc<space>)
  749. if (m_bShowHex && x < right_of_hex_area)
  750. {
  751. if ((x % 3) == 2)
  752. {
  753. ++x;
  754. }
  755. const int col = (x - right_of_address) / 3;
  756. m_nCurrentAddress = m_nTopIndex +
  757. (m_nBytePerRow * row) + col;
  759. if (m_nCurrentAddress > m_nLength)  // past end ?
  760. {
  761. x = m_nLength % m_nBytePerRow;
  762. row = lastVisRow;
  764. x *= 3;
  765. x += (right_of_address + 1);
  767. m_nCurrentAddress = m_nLength;
  768. }
  770. m_eEditMode = ((x % 3) == 0) ? editHigh : editLow;
  772. return CPoint(x, row);
  773. }
  775. const int right_of_ascii_area = right_of_hex_area + m_nBytePerRow + 1;
  776. if (m_bShowAscii && x < right_of_ascii_area)
  777. {
  778. if (x == right_of_hex_area) ++x; // advance from margin
  779. const int col = x - right_of_hex_area - 1;
  780. m_nCurrentAddress = m_nTopIndex + (m_nBytePerRow * row) + col;
  782. if (m_nCurrentAddress > m_nLength)  // past end ?
  783. {
  784. x = m_nLength % m_nBytePerRow;
  785. row = lastVisRow;
  786. x += (right_of_hex_area + 1);
  788. m_nCurrentAddress = m_nLength;
  789. }
  791. m_eEditMode = editAscii;
  792. return CPoint(x, row);
  793. }
  795. return CPoint(-1, -1);
  796. }
  798. void CXTHexEdit::CreateAddressCaret()
  799. {
  800. DestroyCaret();
  801. m_szCaret = CSize(m_nNullWidth * (m_bAddressIsWide ? 8 : 4),
  802. m_nLineHeight);
  803. CreateSolidCaret(m_szCaret.cx, m_szCaret.cy);
  804. }
  806. void CXTHexEdit::CreateEditCaret()
  807. {
  808. DestroyCaret();
  809. m_szCaret = CSize(m_nNullWidth, m_nLineHeight);
  810. CreateSolidCaret(m_szCaret.cx, m_szCaret.cy);
  811. }
  813. void CXTHexEdit::OnMouseMove(UINT nFlags, CPoint point)
  814. {
  815. if (!m_pData)
  816. {
  817. return;
  818. }
  820. if (nFlags & MK_LBUTTON && m_nSelStart != -1)
  821. {
  822. CRect rc;
  823. GetClientRect(&rc);
  824. if (!rc.PtInRect(point))
  825. {
  826. if (point.y < 0)
  827. {
  828. DoVScroll(SB_LINEUP, true);
  829. point.y = 0;
  830. }
  831. else if (point.y > rc.Height())
  832. {
  833. DoVScroll(SB_LINEDOWN, true);
  834. point.y = rc.Height() -1;
  835. }
  836. }
  838. //
  839. // we are selecting
  840. //
  841. int  seo = m_nSelEnd;
  842. CPoint pt = CalcPos(point.x, point.y);
  843. if (pt.x > -1)
  844. {
  845. m_nSelEnd = m_nCurrentAddress;
  846. if (m_eEditMode == editHigh || m_eEditMode == editLow)
  847. {
  848. m_nSelEnd++;
  849. }
  850. }
  851. if (IsSelected())
  852. {
  853. DestroyCaret();
  854. }
  856. if (seo != m_nSelEnd)
  857. {
  858. RedrawWindow();
  859. }
  860. }
  861. }
  863. void CXTHexEdit::UpdateScrollbars()
  864. {
  865. DWORD dwStyle = GetStyle();
  866. SCROLLINFO si;
  868. si.cbSize = sizeof(SCROLLINFO);
  869. si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
  871. if (dwStyle & WS_VSCROLL)
  872. {
  873. bool bDisable = false;
  874. si.nMin = 0;
  875. si.nMax = m_nLength / m_nBytePerRow - 1; // - m_nLinesPerPage + 1;
  876. if (si.nMax < m_nLinesPerPage - 1)
  877. {
  878. si.nMax = 1;
  879. si.nPage = 1;
  880. bDisable = true;
  881. if (m_nTopIndex)
  882. {
  883. m_nTopIndex = 0;
  884. RepositionCaret(m_nCurrentAddress);
  885. }
  886. }
  887. else
  888. {
  889. si.nPage = m_nLinesPerPage - 1;
  891. while (m_nTopIndex / m_nBytePerRow > (si.nMax - m_nLinesPerPage + 2) &&
  892. m_nTopIndex > 0)
  893. {
  894. m_nTopIndex -= m_nBytePerRow;
  895. RepositionCaret(m_nCurrentAddress);
  896. }
  897. }
  898. if (m_nTopIndex < 0) m_nTopIndex = 0;
  899. si.nPos = m_nTopIndex / m_nBytePerRow;
  901. ModifyStyle(0, WS_VSCROLL);
  902. if (!bDisable)
  903. {
  904. SetScrollInfo(SB_VERT, &si, TRUE);
  905. EnableScrollBar(SB_VERT, ESB_ENABLE_BOTH);
  906. }
  907. else
  908. {
  909. si.nMax = si.nMin + 1;
  910. si.nPage = si.nPos = 0;
  911. SetScrollInfo(SB_VERT, &si, TRUE);
  912. EnableScrollBar(SB_VERT, ESB_DISABLE_BOTH);
  913. }
  914. }
  916. if (dwStyle & (WS_HSCROLL | ES_AUTOHSCROLL))
  917. {
  918. CRect rc;
  919. GetClientRect(&rc);
  921. si.nMin = 0;
  922. si.nMax = ((m_bShowAddress ? (m_bAddressIsWide ? 9 : 5) : 0) +
  923. (m_bShowHex ? m_nBytePerRow * 3 : 0) +
  924. (m_bShowAscii ? m_nBytePerRow : 0));
  925. si.nPage = m_nNullWidth == 0 ? 1 : __min(rc.Width() / m_nNullWidth, si.nMax);
  926. si.nPos = 0;
  928. BOOL bVisible = si.nMax * m_nNullWidth >= (int)rc.Width();
  930. if (dwStyle & ES_AUTOHSCROLL)
  931. {
  932. ShowScrollBar(SB_HORZ, bVisible);
  933. }
  935. si.fMask &= ~SIF_POS;
  936. SetScrollInfo(SB_HORZ, &si, TRUE);
  938. if (bVisible && ((dwStyle & ES_AUTOHSCROLL) == 0))
  939. {
  940. EnableScrollBar(SB_HORZ, ESB_ENABLE_BOTH);
  941. }
  942. }
  943. }
  945. void CXTHexEdit::OnLButtonUp(UINT nFlags, CPoint point)
  946. {
  947. if (IsSelected())
  948. {
  949. ReleaseCapture();
  950. }
  952. CWnd::OnLButtonUp(nFlags, point);
  953. }
  955. BOOL CXTHexEdit::IsReadOnly() const
  956. {
  957. if (!IsWindowEnabled() || (GetStyle() & ES_READONLY) == ES_READONLY)
  958. {
  959. return TRUE;
  960. }
  962. return FALSE;
  963. }
  965. void CXTHexEdit::OnChar(UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
  966. {
  967. if (!m_pData)
  968. {
  969. return;
  970. }
  972. if (m_nCurrentAddress < 0)   //Shouldn't happen
  973. {
  974. return;
  975. }
  977. if (nChar == 't')
  978. {
  979. return;
  980. }
  982. if (::GetKeyState(VK_CONTROL) < 0)
  983. {
  984. switch (nChar)
  985. {
  986. case 0x03:
  987. if (IsSelected())
  988. {
  989. OnEditCopy();
  990. }
  991. return;
  993. case 0x16:
  994. OnEditPaste();
  995. return;
  997. case 0x18:
  998. if (IsSelected())
  999. {
  1000. OnEditCut();
  1001. }
  1002. return;
  1004. case 0x1a:
  1005. OnEditUndo();
  1006. return;
  1007. }
  1008. }
  1010. if (IsReadOnly())
  1011. {
  1012. return;
  1013. }
  1015. if (nChar == 0x08) // backspace
  1016. {
  1017. if (GetAllowDeletes())
  1018. {
  1019. if (IsSelected())
  1020. {
  1021. OnEditClear();
  1022. }
  1023. else if (m_nCurrentAddress > 0)
  1024. {
  1025. m_nCurrentAddress--;
  1026. SelDelete(m_nCurrentAddress, m_nCurrentAddress + 1);
  1027. RepositionCaret(m_nCurrentAddress);
  1028. RedrawWindow();
  1029. }
  1030. else
  1031. {
  1032. MessageBeep(0);
  1033. }
  1034. }
  1035. return;
  1036. }
  1038. // can't go past end of buffer
  1039. if ((UINT)m_nCurrentAddress >= m_nMaxLength)
  1040. {
  1041. MessageBeep(0);
  1042. return;
  1043. }
  1045. if (m_eEditMode != editNone)
  1046. {
  1047. // see if need to grow the buffer
  1048. if (m_nCurrentAddress >= m_nLength)
  1049. {
  1050. int iNewLength = (m_nLength + 1);
  1051. LPBYTE p = (LPBYTE) calloc(iNewLength, 1);
  1053. MEMCPY_S(p, m_pData, m_nLength);
  1055. free(m_pData);
  1056. m_pData = p;
  1057. SetSel(-1, -1);
  1058. m_nLength = iNewLength;
  1059. m_bUpdate = TRUE;
  1060. }
  1061. }
  1063. SetSel(-1, -1);
  1064. switch (m_eEditMode)
  1065. {
  1066. case editNone:
  1067. return;
  1069. case editHigh:
  1070. case editLow:
  1071. if (isxdigit(nChar))
  1072. {
  1073. UINT b = 0;
  1075. if (nChar >= 'a')
  1076. b = 10 + nChar - 'a';
  1077. else if (nChar >= 'A')
  1078. b = 10 + nChar - 'A';
  1079. else if (nChar >= '0')
  1080. b = nChar - '0';
  1081. else
  1082. break;
  1084. if (b >= 16)
  1085. break;
  1087. if (m_eEditMode == editHigh)
  1088. {
  1089. m_pData[m_nCurrentAddress] = (unsigned char)((m_pData[m_nCurrentAddress] & 0x0f) | (b << 4));
  1090. }
  1091. else
  1092. {
  1093. m_pData[m_nCurrentAddress] = (unsigned char)((m_pData[m_nCurrentAddress] & 0xf0) | b);
  1094. }
  1095. Move(1, 0);
  1096. }
  1097. break;
  1099. case editAscii:
  1100. m_pData[m_nCurrentAddress] = (unsigned char)nChar;
  1101. Move(1, 0);
  1102. break;
  1103. }
  1104. RedrawWindow();
  1105. }
  1107. void CXTHexEdit::OnKeyDown(UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
  1108. {
  1109. BOOL bShift = (::GetKeyState(VK_SHIFT) < 0);
  1110. switch (nChar)
  1111. {
  1112. case VK_DOWN:
  1113. if (bShift)
  1114. {
  1115. if (!IsSelected())
  1116. {
  1117. m_nSelStart = m_nCurrentAddress;
  1118. }
  1119. Move(0, 1);
  1120. m_nSelEnd = m_nCurrentAddress;
  1121. if (m_eEditMode == editHigh || m_eEditMode == editLow)
  1122. {
  1123. m_nSelEnd++;
  1124. }
  1125. RedrawWindow();
  1126. break;
  1127. }
  1128. else
  1129. {
  1130. SetSel(-1, -1);
  1131. }
  1132. Move(0, 1);
  1133. break;
  1134. case VK_UP:
  1135. if (bShift)
  1136. {
  1137. if (!IsSelected())
  1138. {
  1139. m_nSelStart = m_nCurrentAddress;
  1140. }
  1141. Move(0, -1);
  1142. m_nSelEnd = m_nCurrentAddress;
  1143. RedrawWindow();
  1144. break;
  1145. }
  1146. else
  1147. {
  1148. SetSel(-1, -1);
  1149. }
  1150. Move(0, -1);
  1151. break;
  1152. case VK_LEFT:
  1153. if (bShift)
  1154. {
  1155. if (!IsSelected())
  1156. {
  1157. m_nSelStart = m_nCurrentAddress;
  1158. }
  1159. Move(-1, 0);
  1160. m_nSelEnd = m_nCurrentAddress;
  1161. RedrawWindow();
  1162. break;
  1163. }
  1164. else
  1165. {
  1166. SetSel(-1, -1);
  1167. }
  1168. Move(-1, 0);
  1169. break;
  1170. case VK_RIGHT:
  1171. if (bShift)
  1172. {
  1173. if (!IsSelected())
  1174. {
  1175. m_nSelStart = m_nCurrentAddress;
  1176. }
  1177. Move(1, 0);
  1178. m_nSelEnd = m_nCurrentAddress;
  1179. if (m_eEditMode == editHigh || m_eEditMode == editLow)
  1180. {
  1181. m_nSelEnd++;
  1182. }
  1183. RedrawWindow();
  1184. break;
  1185. }
  1186. else
  1187. {
  1188. SetSel(-1, -1);
  1189. }
  1190. Move(1, 0);
  1191. break;
  1192. case VK_PRIOR:
  1193. if (bShift)
  1194. {
  1195. if (!IsSelected())
  1196. {
  1197. m_nSelStart = m_nCurrentAddress;
  1198. }
  1199. DoVScroll(SB_PAGEUP, true);
  1200. Move(0, 0);
  1201. m_nSelEnd = m_nCurrentAddress;
  1202. RedrawWindow();
  1203. break;
  1204. }
  1205. else
  1206. {
  1207. SetSel(-1, -1);
  1208. }
  1209. DoVScroll(SB_PAGEUP, true);
  1210. Move(0, 0);
  1211. break;
  1212. case VK_NEXT:
  1213. if (bShift)
  1214. {
  1215. if (!IsSelected())
  1216. {
  1217. m_nSelStart = m_nCurrentAddress;
  1218. }
  1219. DoVScroll(SB_PAGEDOWN, true);
  1220. Move(0, 0);
  1221. m_nSelEnd = m_nCurrentAddress;
  1222. RedrawWindow();
  1223. break;
  1224. }
  1225. else
  1226. {
  1227. SetSel(-1, -1);
  1228. }
  1229. DoVScroll(SB_PAGEDOWN, true);
  1230. Move(0, 0);
  1231. break;
  1232. case VK_HOME:
  1233. if (m_eEditMode == editLow)
  1234. {
  1235. m_eEditMode = editHigh;
  1236. }
  1237. if (bShift)
  1238. {
  1239. if (!IsSelected())
  1240. {
  1241. m_nSelStart = m_nCurrentAddress;
  1242. }
  1243. if (::GetKeyState(VK_CONTROL) < 0)
  1244. {
  1245. DoVScroll(SB_THUMBTRACK, true);
  1246. Move(0, 0);
  1247. }
  1248. else
  1249. {
  1250. m_nCurrentAddress /= m_nBytePerRow;
  1251. m_nCurrentAddress *= m_nBytePerRow;
  1252. Move(0, 0);
  1253. }
  1254. m_nSelEnd = m_nCurrentAddress;
  1255. RedrawWindow();
  1256. break;
  1257. }
  1258. else
  1259. {
  1260. SetSel(-1, -1);
  1261. }
  1262. if (::GetKeyState(VK_CONTROL) < 0)
  1263. {
  1264. m_nTopIndex = m_nCurrentAddress = 0;
  1265. UpdateScrollbars();
  1266. RepositionCaret(m_nCurrentAddress);
  1267. RedrawWindow();
  1268. }
  1269. else
  1270. {
  1271. m_nCurrentAddress /= m_nBytePerRow;
  1272. m_nCurrentAddress *= m_nBytePerRow;
  1273. Move(0, 0);
  1274. }
  1275. break;
  1276. case VK_END:
  1277. if (m_eEditMode == editLow)
  1278. {
  1279. m_eEditMode = editHigh;
  1280. }
  1281. if (bShift)
  1282. {
  1283. if (!IsSelected())
  1284. {
  1285. m_nSelStart = m_nCurrentAddress;
  1286. }
  1287. if (::GetKeyState(VK_CONTROL) < 0)
  1288. {
  1289. m_nCurrentAddress = m_nLength-1;
  1290. DoVScroll(SB_PAGEDOWN, false);
  1291. Move(0, 0);
  1292. }
  1293. else
  1294. {
  1295. m_nCurrentAddress /= m_nBytePerRow;
  1296. m_nCurrentAddress *= m_nBytePerRow;
  1297. m_nCurrentAddress += m_nBytePerRow - 1;
  1298. if (m_nCurrentAddress > m_nLength)
  1299. {
  1300. m_nCurrentAddress = m_nLength;
  1301. }
  1302. Move(0, 0);
  1303. }
  1304. m_nSelEnd = m_nCurrentAddress;
  1305. RedrawWindow();
  1306. break;
  1307. }
  1308. else
  1309. {
  1310. SetSel(-1, -1);
  1311. }
  1312. if (::GetKeyState(VK_CONTROL) < 0)
  1313. {
  1314. m_nCurrentAddress = m_nLength;
  1315. DoVScroll(SB_PAGEDOWN, false);
  1316. Move(0, 0);
  1317. }
  1318. else
  1319. {
  1320. m_nCurrentAddress /= m_nBytePerRow;
  1321. m_nCurrentAddress *= m_nBytePerRow;
  1322. m_nCurrentAddress += m_nBytePerRow - 1;
  1323. if (m_nCurrentAddress > m_nLength)
  1324. m_nCurrentAddress = m_nLength;
  1325. Move(0, 0);
  1326. }
  1327. break;
  1328. case VK_INSERT:
  1329. SelInsert(m_nCurrentAddress, __max(1, m_nSelEnd-m_nSelStart));
  1330. RepositionCaret(m_nCurrentAddress);
  1331. RedrawWindow();
  1332. break;
  1333. case VK_DELETE:
  1334. if (GetAllowDeletes())
  1335. {
  1336. if (IsSelected())
  1337. {
  1338. OnEditClear();
  1339. }
  1340. else
  1341. {
  1342. if (m_nCurrentAddress < m_nLength)
  1343. {
  1344. SelDelete(m_nCurrentAddress, m_nCurrentAddress + 1);
  1345. RedrawWindow();
  1346. }
  1347. else
  1348. {
  1349. MessageBeep(0);
  1350. }
  1351. }
  1352. }
  1353. break;
  1355. case VK_TAB:
  1356. {
  1357. int next_win_sel = 0;
  1358. switch (m_eEditMode)
  1359. {
  1360. case editNone:
  1361. m_eEditMode = editHigh;
  1362. break;
  1363. case editHigh:
  1364. case editLow:
  1365. if (bShift)
  1366. {
  1367. next_win_sel = GW_HWNDPREV;
  1368. }
  1369. else
  1370. {
  1371. m_eEditMode = editAscii;
  1372. }
  1373. break;
  1374. case editAscii:
  1375. if (bShift)
  1376. {
  1377. m_eEditMode = editHigh;
  1378. }
  1379. else
  1380. {
  1381. next_win_sel = GW_HWNDNEXT;
  1382. }
  1383. break;
  1384. }
  1385. if (next_win_sel)
  1386. {
  1387. CWnd *pWnd = this;
  1388. for (;;)
  1389. {
  1390. pWnd = pWnd->GetNextWindow(next_win_sel);
  1391. if (pWnd == this)
  1392. {
  1393. break;
  1394. }
  1395. if (pWnd == NULL)
  1396. {
  1397. if (next_win_sel == GW_HWNDNEXT)
  1398. {
  1399. pWnd = GetNextWindow(GW_HWNDFIRST);
  1400. }
  1401. else
  1402. {
  1403. pWnd = GetNextWindow(GW_HWNDLAST);
  1404. }
  1405. }
  1406. if (pWnd->GetStyle() & WS_TABSTOP)
  1407. {
  1408. pWnd->SetFocus();
  1409. break;
  1410. }
  1411. if (pWnd == this)
  1412. {
  1413. m_eEditMode = editHigh;
  1414. Move(0, 0);
  1415. break;
  1416. }
  1417. }
  1418. }
  1419. else
  1420. {
  1421. Move(0, 0);
  1422. }
  1423. break;
  1424. }
  1425. }
  1426. }
  1428. void CXTHexEdit::Move(int x, int y)
  1429. {
  1430. switch (m_eEditMode)
  1431. {
  1432. case editNone:
  1433. return;
  1435. case editHigh:
  1436. if (x != 0)
  1437. m_eEditMode = editLow;
  1438. if (x == -1)
  1439. m_nCurrentAddress--;
  1440. m_nCurrentAddress += y* m_nBytePerRow;
  1441. break;
  1443. case editLow:
  1444. if (x != 0)
  1445. m_eEditMode = editHigh;
  1446. if (x == 1)
  1447. m_nCurrentAddress++;
  1448. m_nCurrentAddress += y* m_nBytePerRow;
  1449. break;
  1451. case editAscii:
  1452. {
  1453. m_nCurrentAddress += x;
  1454. m_nCurrentAddress += y*m_nBytePerRow;
  1455. }
  1456. break;
  1457. }
  1459. if (m_nCurrentAddress < 0)
  1460. {
  1461. m_nCurrentAddress = 0;
  1462. }
  1464. if (m_nCurrentAddress >= m_nLength)
  1465. {
  1466. m_nCurrentAddress = m_nLength;
  1467. }
  1469. if ((x | y) != 0 && m_nCurrentAddress < m_nTopIndex)
  1470. {
  1471. DoVScroll(SB_LINEUP, false);
  1472. }
  1473. if ((x | y) != 0 &&
  1474. m_nCurrentAddress >= m_nTopIndex + m_nLinesPerPage*m_nBytePerRow)
  1475. {
  1476. DoVScroll(SB_LINEDOWN, false);
  1477. }
  1478. //ScrollIntoView(m_nCurrentAddress);
  1479. RepositionCaret(m_nCurrentAddress);
  1480. }
  1482. void CXTHexEdit::SetSel(int nSelStart, int nSelEnd)
  1483. {
  1484. #ifdef _DEBUG
  1485. _CrtCheckMemory();
  1486. #endif
  1488. if (GetFocus() == this)
  1489. DestroyCaret();
  1490. m_nSelStart = nSelStart;
  1491. m_nSelEnd = nSelEnd;
  1492. if (!IsWindow(m_hWnd))
  1493. return;
  1494. RedrawWindow();
  1495. if (GetFocus() == this)
  1496. {
  1497. if (m_ptEditPos.x == 0 && m_bShowAddress)
  1498. {
  1499. CreateAddressCaret();
  1500. }
  1501. else
  1502. {
  1503. CreateEditCaret();
  1504. }
  1505. RepositionCaret(m_nCurrentAddress);
  1507. if (m_bShowCaret)
  1508. ShowCaret();
  1509. }
  1510. }
  1512. void CXTHexEdit::RepositionCaret(int p)
  1513. {
  1514. if (GetFocus() != this)
  1515. return;
  1517. int x, y;
  1519. y = (p - m_nTopIndex) / m_nBytePerRow;
  1520. x = (p - m_nTopIndex) % m_nBytePerRow;
  1522. switch (m_eEditMode)
  1523. {
  1524. case editNone:
  1525. CreateAddressCaret();
  1526. x = m_nOffAddress;
  1527. break;
  1528. case editHigh:
  1529. CreateEditCaret();
  1530. x *= m_nNullWidth * 3;
  1531. x += m_nOffHex;
  1532. break;
  1533. case editLow:
  1534. CreateEditCaret();
  1535. x *= m_nNullWidth * 3;
  1536. x += m_nNullWidth;
  1537. x += m_nOffHex;
  1538. break;
  1539. case editAscii:
  1540. CreateEditCaret();
  1541. x *= m_nNullWidth;
  1542. x += m_nOffAscii;
  1543. break;
  1544. }
  1545. m_ptEditPos.x = x;
  1546. m_ptEditPos.y = y*m_nLineHeight;
  1547. CRect rc;
  1548. GetClientRect(&rc);
  1549. CRect rcCarret(m_ptEditPos, m_szCaret);
  1550. CRect rcInt;
  1551. rcInt.IntersectRect(rcCarret, rc);
  1552. if (rcInt == rcCarret)
  1553. {
  1554. SetCaretPos(m_ptEditPos);
  1556. if (m_bShowCaret)
  1557. ShowCaret();
  1558. }
  1559. }
  1561. void CXTHexEdit::ScrollIntoView(int p)
  1562. {
  1563. if (p < m_nTopIndex || p > m_nTopIndex + m_nLinesPerPage*m_nBytePerRow)
  1564. {
  1565. m_nTopIndex = (p/m_nBytePerRow) * m_nBytePerRow;
  1566. m_nTopIndex -= (m_nLinesPerPage / 3) * m_nBytePerRow;
  1567. if (m_nTopIndex < 0)
  1568. {
  1569. m_nTopIndex = 0;
  1570. }
  1572. UpdateScrollbars();
  1573. RedrawWindow();
  1574. }
  1575. }
  1577. void CXTHexEdit::OnContextMenu(CWnd*, CPoint point)
  1578. {
  1579. if (point.x == -1 && point.y == -1)
  1580. {
  1581. //keystroke invocation
  1582. CRect rect;
  1583. GetClientRect(rect);
  1584. ClientToScreen(rect);
  1586. point = rect.TopLeft();
  1587. point.Offset(5, 5);
  1588. }
  1590. CMenu menu;
  1591. XTPResourceManager()->LoadMenu(&menu, XT_IDM_POPUP);
  1593. CMenu* pPopup = menu.GetSubMenu(1);
  1594. ASSERT(pPopup != NULL);
  1595. if (!pPopup)
  1596. return;
  1598. const int DISABLE_FLAGS = MF_GRAYED | MF_DISABLED | MF_BYCOMMAND;
  1600. pPopup->EnableMenuItem(ID_EDIT_UNDO, DISABLE_FLAGS);
  1602. if (!GetAllowDeletes())
  1603. {
  1604. pPopup->EnableMenuItem(ID_EDIT_CLEAR, DISABLE_FLAGS);
  1605. pPopup->EnableMenuItem(ID_EDIT_CUT, DISABLE_FLAGS);
  1606. }
  1608. if (!IsSelected())
  1609. {
  1610. pPopup->EnableMenuItem(ID_EDIT_CLEAR, DISABLE_FLAGS);
  1611. pPopup->EnableMenuItem(ID_EDIT_CUT, DISABLE_FLAGS);
  1612. pPopup->EnableMenuItem(ID_EDIT_COPY, DISABLE_FLAGS);
  1613. }
  1615. if (OpenClipboard())
  1616. {
  1617. if (!IsClipboardFormatAvailable(CF_TEXT) &&
  1618. !IsClipboardFormatAvailable(CF_BINARY))
  1619. {
  1620. pPopup->EnableMenuItem(ID_EDIT_PASTE, DISABLE_FLAGS);
  1621. }
  1622. ::CloseClipboard();
  1623. }
  1625. XTFuncContextMenu(pPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this, XT_IDR_TBAR_HEXEDIT);
  1626. }
  1628. void CXTHexEdit::OnEditClear()
  1629. {
  1630. if (IsReadOnly())
  1631. {
  1632. return;
  1633. }
  1635. if (!GetAllowDeletes())
  1636. return;
  1638. NormalizeSel();
  1639. m_nCurrentAddress = m_nSelStart;
  1640. SelDelete(m_nSelStart, m_nSelEnd);
  1641. RepositionCaret(m_nCurrentAddress);
  1642. RedrawWindow();
  1643. }
  1645. void CXTHexEdit::OnEditCopy()
  1646. {
  1647. if (!OpenClipboard()) return;
  1649. NormalizeSel();
  1651. ::EmptyClipboard();
  1653. const int dwLen = m_nSelEnd - m_nSelStart;
  1654. HGLOBAL hMemb = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT, dwLen);
  1655. if (!hMemb)
  1656. {
  1657. CloseClipboard();
  1658. return;
  1659. }
  1661. // copy binary
  1662. ASSERT(hMemb != NULL);
  1663. LPBYTE  p = (BYTE*)::GlobalLock(hMemb);
  1664. if (!p)
  1665. return;
  1666. MEMCPY_S(p, m_pData + m_nSelStart, dwLen);
  1667. ::GlobalUnlock(hMemb);
  1669. HGLOBAL hMema = NULL;
  1670. if (m_eEditMode != editAscii)
  1671. {
  1672. hMema = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT, dwLen * 3 + 1);
  1673. if (!hMema)
  1674. {
  1675. CloseClipboard();
  1676. return;
  1677. }
  1679. // copy ascii
  1680. p = (BYTE*)::GlobalLock(hMema);
  1681. if (!p)
  1682. return;
  1684. int i;
  1685. for (i = 0; i < dwLen;)
  1686. {
  1687. TOHEX(m_pData[m_nSelStart + i], p);
  1688. *p++ = ' ';
  1689. i++;
  1690. }
  1692. ::GlobalUnlock(hMema);
  1693. }
  1694. else
  1695. {
  1696. hMema = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT, dwLen + 1);
  1697. if (!hMema)
  1698. {
  1699. CloseClipboard();
  1700. return;
  1701. }
  1703. // copy ascii
  1704. p = (BYTE*)::GlobalLock(hMema);
  1705. if (!p)
  1706. return;
  1707. MEMCPY_S(p, m_pData + m_nSelStart, dwLen);
  1708. p[dwLen] = 0;
  1710. for (int i = 0; i < dwLen; p++, i++)
  1711. {
  1712. if (!isprint(*p))
  1713. {
  1714. *p = '.';
  1715. }
  1716. }
  1717. ::GlobalUnlock(hMema);
  1718. }
  1720. ::SetClipboardData(CF_TEXT, hMema);
  1721. ::SetClipboardData(CF_BINARY, hMemb);
  1723. VERIFY(CloseClipboard());
  1724. }
  1726. void CXTHexEdit::OnEditCut()
  1727. {
  1728. if (IsReadOnly())
  1729. return;
  1731. OnEditCopy();
  1732. SelDelete(m_nSelStart, m_nSelEnd);
  1733. RedrawWindow();
  1734. }
  1736. void CXTHexEdit::OnEditPaste()
  1737. {
  1738. if (IsReadOnly())
  1739. return;
  1741. if (!OpenClipboard()) return;
  1743. HGLOBAL hmem = NULL;
  1744. LPBYTE p = NULL;
  1745. DWORD dwLen = 0;
  1747. if (::IsClipboardFormatAvailable(CF_BINARY))
  1748. {
  1749. hmem = ::GetClipboardData(CF_BINARY);
  1750. p = hmem ? (BYTE*)::GlobalLock(hmem) : NULL;
  1751. dwLen = hmem ? (DWORD)::GlobalSize(hmem) : 0;
  1752. }
  1753. else if (::IsClipboardFormatAvailable(CF_TEXT))
  1754. {
  1755. hmem = ::GetClipboardData(CF_TEXT);
  1756. p = hmem ? (BYTE*)::GlobalLock(hmem) : NULL;
  1757. dwLen = p ? (DWORD)strlen((char*)p) : 0;
  1758. }
  1760. if (p && dwLen > 0)
  1761. {
  1762. int     insert;
  1764. if (m_nCurrentAddress > m_nLength)
  1765. m_nCurrentAddress = m_nLength;
  1767. int     oa = m_nCurrentAddress;
  1769. NormalizeSel();
  1770. if (m_nSelStart == -1)
  1771. {
  1772. if (m_eEditMode == editLow)
  1773. {
  1774. m_nCurrentAddress++;
  1775. }
  1776. if (m_nCurrentAddress > m_nLength)
  1777. {
  1778. m_nCurrentAddress = m_nLength;
  1779. }
  1780. insert = m_nCurrentAddress;
  1781. SelInsert(m_nCurrentAddress, dwLen);
  1782. }
  1783. else
  1784. {
  1785. insert = m_nSelStart;
  1786. SelDelete(m_nSelStart, m_nSelEnd);
  1787. SelInsert(insert, dwLen);
  1788. SetSel(-1, -1);
  1789. }
  1791. if (insert + dwLen > m_nMaxLength)
  1792. {
  1793. dwLen = m_nMaxLength - insert;
  1794. }
  1796. MEMCPY_S(m_pData + insert, p, dwLen);
  1798. #ifdef _DEBUG
  1799. _CrtCheckMemory();
  1800. #endif
  1802. m_nCurrentAddress = oa;
  1803. RedrawWindow();
  1804. }
  1806. if (hmem)
  1807. {
  1808. ::GlobalUnlock(hmem);
  1809. }
  1811. ::CloseClipboard();
  1812. }
  1814. void CXTHexEdit::OnEditSelectAll()
  1815. {
  1816. m_nSelStart = 0;
  1817. m_nSelEnd = m_nLength;
  1818. DestroyCaret();
  1819. RedrawWindow();
  1820. }
  1822. void CXTHexEdit::OnEditUndo()
  1823. {
  1824. }
  1826. void CXTHexEdit::NormalizeSel()
  1827. {
  1828. if (m_nSelStart > m_nSelEnd)
  1829. {
  1830. int nSelStart = m_nSelStart;
  1831. m_nSelStart = m_nSelEnd;
  1832. m_nSelEnd = nSelStart;
  1833. }
  1835. if (m_nSelStart > m_nLength)
  1836. {
  1837. m_nSelStart = m_nLength;
  1838. }
  1840. if (m_nSelEnd > m_nLength)
  1841. {
  1842. m_nSelEnd = m_nLength;
  1843. }
  1844. }
  1846. void CXTHexEdit::GetSel(int& nSelStart, int& nSelEnd)
  1847. {
  1848. nSelStart = m_nSelStart;
  1849. nSelEnd = m_nSelEnd;
  1851. if (nSelStart > nSelEnd)
  1852. {
  1853. nSelStart = m_nSelEnd;
  1854. nSelEnd = m_nSelStart;
  1855. }
  1857. if (nSelStart > m_nLength)
  1858. nSelStart = m_nLength;
  1860. if (nSelEnd > m_nLength)
  1861. nSelEnd = m_nLength;
  1862. }
  1864. void CXTHexEdit::SelDelete(int nSelStart, int nSelEnd)
  1865. {
  1866. if (!GetAllowDeletes())
  1867. return;
  1869. #ifdef _DEBUG
  1870. _CrtCheckMemory();
  1871. #endif
  1873. if (nSelStart >= m_nLength)
  1874. return;
  1876. NormalizeSel();
  1878. const int nSelSize = (nSelEnd-nSelStart);
  1879. const int newLength = m_nLength - nSelSize;
  1880. if (newLength < 0)
  1881. return;
  1883. MEMMOVE_S(m_pData + nSelStart, m_pData + nSelEnd,
  1884. m_nLength - nSelEnd);
  1886. SetSel(-1, -1);
  1888. m_nLength = newLength;
  1889. if (m_nCurrentAddress > m_nLength)
  1890. {
  1891. m_nCurrentAddress = m_nLength;
  1892. RepositionCaret(m_nCurrentAddress);
  1893. }
  1894. m_bUpdate = TRUE;
  1895. }
  1897. void CXTHexEdit::SelInsert(int nSelStart, int nLength)
  1898. {
  1899. if ((UINT)(m_nLength + nLength) > m_nMaxLength)
  1900. {
  1901. nLength = (int)m_nMaxLength - m_nLength;
  1902. }
  1903. if (nLength <= 0)
  1904. {
  1905. MessageBeep(0);
  1906. return;
  1907. }
  1908. if (nSelStart > m_nLength)
  1909. {
  1910. nSelStart = m_nLength;
  1911. }
  1913. LPBYTE p = (LPBYTE) calloc(m_nLength + nLength, 1);
  1915. MEMCPY_S(p, m_pData, nSelStart);
  1917. if (m_nLength > nSelStart)
  1918. {
  1919. MEMCPY_S(p + nSelStart + nLength, m_pData + nSelStart, (m_nLength - nSelStart));
  1920. }
  1922. free(m_pData);
  1923. m_pData = p;
  1924. SetSel(-1, -1);
  1925. m_nLength = m_nLength + nLength;
  1926. m_bUpdate = TRUE;
  1927. }
  1929. void CXTHexEdit::SetData(LPBYTE p, int nLength, int nMaxLength)
  1930. {
  1931. if (m_pData)
  1932. free(m_pData);
  1934. m_pData = (LPBYTE) malloc(nLength);
  1935. MEMCPY_S(m_pData, p, nLength);
  1937. SetSel(-1, -1);
  1938. m_nMaxLength = nMaxLength < 0 ? -1 : __max(nMaxLength, nLength);
  1939. m_nLength = nLength;
  1940. m_nCurrentAddress = 0;
  1941. m_ptEditPos.x = m_ptEditPos.y = 0;
  1942. m_eEditMode = editHigh;
  1943. m_nTopIndex = 0;
  1944. m_bUpdate = TRUE;
  1946. if (m_hWnd)
  1947. {
  1948. UpdateScrollbars();
  1949. RepositionCaret(m_nCurrentAddress);
  1950. RedrawWindow();
  1952. // this will force the scroll bars to update if this is before the
  1953. // initial update
  1954. if (GetStyle() & WS_VSCROLL)
  1955. {
  1956. PostMessage(WM_VSCROLL, (WPARAM)-1, 0);
  1957. }
  1958. }
  1959. }
  1961. void CXTHexEdit::OnHScroll(UINT nSBCode, UINT /*nPos*/, CScrollBar* /*pScrollBar*/)
  1962. {
  1963. SCROLLINFO si;
  1964. ZeroMemory(&si, sizeof(SCROLLINFO));
  1965. si.cbSize = sizeof(SCROLLINFO);
  1966. si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS | SIF_TRACKPOS;
  1967. VERIFY(::GetScrollInfo(m_hWnd, SB_HORZ, &si));
  1969. int newpos = si.nPos;
  1971. switch (nSBCode)
  1972. {
  1973. case SB_LINELEFT:
  1974. --newpos;
  1975. break;
  1977. case SB_LINERIGHT:
  1978. ++newpos;
  1979. break;
  1981. case SB_PAGELEFT:
  1982. newpos -= si.nPage;
  1983. break;
  1985. case SB_PAGERIGHT:
  1986. newpos += si.nPage;
  1987. break;
  1989. case SB_THUMBTRACK:
  1990. newpos = si.nTrackPos;
  1991. break;
  1992. }
  1994. if (newpos < 0)
  1995. {
  1996. newpos = 0;
  1997. }
  1998. else if (newpos > si.nMax)
  1999. {
  2000. newpos = si.nMax;
  2001. }
  2003. if (newpos != si.nPos)
  2004. {
  2005. m_bUpdate = true;
  2006. ::SetScrollPos(m_hWnd, SB_HORZ, newpos, TRUE);
  2007. RedrawWindow();
  2008. RepositionCaret(m_nCurrentAddress);
  2009. }
  2010. }
  2012. void CXTHexEdit::OnLButtonDblClk(UINT /*nFlags*/, CPoint /*point*/)
  2013. {
  2014. }
  2016. DWORD CXTHexEdit::SetAddressBase(DWORD dwBase)
  2017. {
  2018. DWORD dwOldAddress = m_dwBaseAddress;
  2019. m_dwBaseAddress = dwBase;
  2020. m_bUpdate = TRUE;
  2022. return dwOldAddress;
  2023. }
  2025. void CXTHexEdit::OnSize(UINT nType, int cx, int cy)
  2026. {
  2027. BOOL bVisible = GetStyle() & WS_VISIBLE;
  2029. if (bVisible) SetRedraw(FALSE);
  2031. CXTHexEditBase::OnSize(nType, cx, cy);
  2033. if (m_bDynamicBPR)
  2034. {
  2035. RecalcBPR();
  2036. }
  2038. m_bUpdate = TRUE;
  2039. UpdateScrollbars();
  2041. if (bVisible)
  2042. {
  2043. SetRedraw(TRUE);
  2044. Invalidate();
  2045. UpdateWindow();
  2046. }
  2047. }
  2049. void CXTHexEdit::RecalcBPR()
  2050. {
  2051. CDC* dc = GetDC();
  2052. HGDIOBJ hOldFont = dc->SelectObject(&m_fontHex);
  2054. dc->GetCharWidth('0', '0', &m_nNullWidth);
  2055. CRect rc;
  2057. GetClientRect(rc);
  2058. int cx = rc.Width();
  2060. if (m_bShowAddress)
  2061. cx -= m_nOffHex;
  2063. if (m_bShowAscii && m_bShowHex)
  2064. {
  2065. m_nBytePerRow = ((cx * 2) / 3) / (3 * m_nNullWidth);    // 2/3rd is hex, 1/3rd is ascii
  2066. }
  2067. else if (m_bShowHex)
  2068. {
  2069. m_nBytePerRow = cx / (3 * m_nNullWidth);
  2070. }
  2071. else if (m_bShowAscii)
  2072. {
  2073. m_nBytePerRow = cx / m_nNullWidth;
  2074. }
  2075. m_bUpdate = TRUE;
  2077. if (m_nBytePerRow <= 0)
  2078. m_nBytePerRow = 1;
  2080. dc->SelectObject(hOldFont);
  2081. ReleaseDC(dc);
  2082. }
  2084. void CXTHexEdit::OnNcPaint()
  2085. {
  2086. // Use the OnNcPaint() handler to prevent the caret
  2087. // from being shown when the control is first displayed
  2089. CXTHexEditBase::OnNcPaint(); // Be sure and call the parent class
  2090. //HideCaret();  // Hide the caret
  2091. }
  2093. BOOL CXTHexEdit::OnMouseWheel(UINT /*nFlags*/, short zDelta, CPoint /*pt*/)
  2094. {
  2095. OnVScroll(zDelta < 0 ? SB_LINEDOWN : SB_LINEUP, 0, NULL);
  2096. return TRUE;
  2097. }
  2099. void CXTHexEdit::EnableScrollBars(bool /*bVertical*/, bool /*bHorizontal*/)
  2100. {
  2101. XT_ERROR_MSG(
  2102. "CXTHexEdit::EnableScrollBars has been deprecated.n"
  2103. "n"
  2104. "You should now set scroll bars for the control through WS_HSCROLL/WS_VSCROLL and/or the resource editor."
  2105. );
  2106. }
  2108. int CXTHexEdit::GetData(LPBYTE pData, int nLength)
  2109. {
  2110. MEMCPY_S(pData, m_pData, __min(nLength, m_nLength));
  2111. return m_nLength;
  2112. }