上位机MFC实现十六进制编辑框

效果演示

例程实现在编辑框中添加十六进制和ASCII文本，可以通过单选框选择是否显示。
地址也可以通过选择设置，效果如上图。
例程使用的两文件可以在帖子底部使用或直接下载工程源代码使用：

请点击此处下载

请先注册会员后在进行下载

已注册会员，请先登录后下载

文件名称:Ctest.rar 
文件大小:47.71 KB  售价:10金币
下载权限: 不限 以上或 VIP会员   [购买捐助会员]   [充值积分]  

实现过程
1.同样也是新建一个工程，这里建立基于对话框的工程，
按照上图添加单选框，编辑框，与滑块控件，并进行界面排序。

2.复制例程目录两文件HEXEDITCTRL.CPP，HEXEDITCTRL.H到自己工程根目录中，
并导入到工程，两文件源代码可以在帖子底部复制使用。
操作之后，自己的工程目录内就多出了一个集成类CHexEdit，如下图：


3.紧接着就产类的使用。
在主对话框头文件内包含#include "hexeditctrl.h"
并添加变量
        //{{AFX_DATA(CCtestDlg)
        enum { IDD = IDD_CTEST_DIALOG };
        CSliderCtrl        m_slider;
        CHexEdit        m_Edit;
        //}}AFX_DATA

void CCtestDlg:oDataExchange(CDataExchange* pDX)
{
        CDialog:oDataExchange(pDX);
        DDX_Control(pDX, IDC_SLIDER1, m_slider);
        DDX_Control(pDX, IDC_HEXEDIT1, m_Edit);
        //}}AFX_DATA_MAP
}

并初始化变量
        m_slider.SetRange(1, 16);
        m_slider.SetPos(8);


编译时会提示少一个菜单ID，CG_IDR_POPUP_HEX_EDIT，
添加或从例程复制使用。

4.添加几个单选框的点击处理函数

1. void CHexEditDlg::OnCheck1()
   
2. {
   
3.         UpdateData(TRUE);
   
4.         m_Edit.SetOptions(m_address, m_hex, m_ascii, m_48);
   
5.         m_Edit.RedrawWindow();
   
6. }
   
7. 
   
8. void CHexEditDlg::OnCheck2()
   
9. {
   
10.         UpdateData(TRUE);
    
11.         m_Edit.SetOptions(m_address, m_hex, m_ascii, m_48);
    
12.         m_Edit.RedrawWindow();
    
13. }
    
14. 
    
15. void CHexEditDlg::OnCheck3()
    
16. {
    
17.         UpdateData(TRUE);
    
18.         m_Edit.SetOptions(m_address, m_hex, m_ascii, m_48);
    
19.         m_Edit.RedrawWindow();
    
20. }
    
21. 
    
22. void CHexEditDlg::OnCheck4()
    
23. {
    
24.         UpdateData(TRUE);
    
25.         m_Edit.SetOptions(m_address, m_hex, m_ascii, m_48);
    
26.         m_Edit.RedrawWindow();
    
27. }

复制代码

运行程序，就可以点击界面的几个单选框查看效果，
编辑框自带的文本可以通过去除集成类头文件的#define DEMO 1，去除。

5.最后就滑块功能的实现，在主对话框添加对消息WM_HSCROLL的处理便可：
void CCtestDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
        m_Edit.SetBPR(m_slider.GetPos());
        m_Edit.RedrawWindow();
        CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

下面是两个文件的源代码：

1. /////////////////////////////////////////////////////////////////////////////
   
2. // CHexEdit window
   
3. 
   
4. class CHexEdit : public CEdit
   
5. {
   
6. // Construction
   
7. public:
   
8.         CHexEdit();
   
9. 
   
10.         enum EDITMODE{       
    
11.                         EDIT_NONE,
    
12.                         EDIT_ASCII,
    
13.                         EDIT_HIGH,
    
14.                         EDIT_LOW
    
15.         } ;
    
16. // Attributes
    
17. public:
    
18.         LPBYTE                m_pData;                        // pointer to data
    
19.         int                        m_length;                        // length of data
    
20.         int                        m_topindex;                        // offset of first visible byte on screen
    
21. 
    
22.         int                        m_currentAddress;        // address under cursor
    
23.         EDITMODE        m_currentMode;                // current editing mode: address/hex/ascii
    
24.         int                        m_selStart;                        // start address of selection
    
25.         int                        m_selEnd;                        // end address of selection
    
26. 
    
27.         int                        m_bpr;                                // byte per row
    
28.         int                        m_lpp;                                // lines per page
    
29.         BOOL                m_bShowAddress;
    
30.         BOOL                m_bShowAscii;
    
31.         BOOL                m_bShowHex;
    
32.         BOOL                m_bAddressIsWide;
    
33.        
    
34.         BOOL                m_bNoAddressChange;        // internally used
    
35.         BOOL                m_bHalfPage;
    
36.        
    
37.         CFont                m_Font;
    
38.         int                        m_lineHeight;
    
39.         int                        m_nullWidth;
    
40.         BOOL                m_bUpdate;
    
41. 
    
42.         int                        m_offHex,
    
43.                                 m_offAscii,
    
44.                                 m_offAddress;
    
45. 
    
46.         CPoint                m_editPos;
    
47. 
    
48. // Operations
    
49. public:
    
50. 
    
51. // Overrides
    
52.         // ClassWizard generated virtual function overrides
    
53.         //{{AFX_VIRTUAL(CHexEdit)
    
54.         public:
    
55.         virtual BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL);
    
56.         protected:
    
57.         virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    
58.         //}}AFX_VIRTUAL
    
59. 
    
60. // Implementation
    
61. public:
    
62.         int GetData(LPBYTE p, int len);
    
63.         void SetData(LPBYTE p, int len);
    
64.         CSize GetSel(void);
    
65.         void SetSel(int s, int e);
    
66.         void SetBPR(int bpr);
    
67.         void SetOptions(BOOL a, BOOL h, BOOL c, BOOL w);
    
68.         virtual ~CHexEdit();
    
69. 
    
70.         // Generated message map functions
    
71. protected:
    
72.         void                ScrollIntoView(int p);
    
73.         void                RepositionCaret(int p);
    
74.         void                Move(int x, int y);
    
75.         inline BOOL IsSelected(void);
    
76.         void                UpdateScrollbars(void);
    
77.         void                CreateEditCaret(void);
    
78.         void                CreateAddressCaret(void);
    
79.         CPoint                CalcPos(int x, int y);
    
80.         void                SelInsert(int s, int l);
    
81.         void                SelDelete(int s, int e);
    
82.         inline void NormalizeSel(void);
    
83.         afx_msg void OnContextMenu(CWnd*, CPoint point);
    
84.         //{{AFX_MSG(CHexEdit)
    
85.         afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
    
86.         afx_msg void OnKillFocus(CWnd* pNewWnd);
    
87.         afx_msg void OnPaint();
    
88.         afx_msg void OnSetFocus(CWnd* pOldWnd);
    
89.         afx_msg void OnSize(UINT nType, int cx, int cy);
    
90.         afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
    
91.         afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
    
92.         afx_msg UINT OnGetDlgCode();
    
93.         afx_msg BOOL OnEraseBkgnd(CDC* pDC);
    
94.         afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    
95.         afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
    
96.         afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    
97.         afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
    
98.         afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
    
99.         afx_msg void OnEditClear();
    
100.         afx_msg void OnEditCopy();
     
101.         afx_msg void OnEditCut();
     
102.         afx_msg void OnEditPaste();
     
103.         afx_msg void OnEditSelectAll();
     
104.         afx_msg void OnEditUndo();
     
105.         //}}AFX_MSG
     
106. 
     
107.         DECLARE_MESSAGE_MAP()
     
108. };
     

复制代码

1. // HexEdit.cpp : Defines the class behaviors for the application.
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. #include "HexEditCtrl.h"
   
6. #include <ctype.h>
   
7. #include <afxole.h>
   
8. #include <afxdisp.h>
   
9. #include "resource.h"
   
10. 
    
11. #ifdef _DEBUG
    
12. #define new DEBUG_NEW
    
13. #undef THIS_FILE
    
14. static char THIS_FILE[] = __FILE__;
    
15. #endif
    
16. 
    
17. 
    
18. char hextable[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    
19. #define TOHEX(a, b)        {*b++ = hextable[a >> 4];*b++ = hextable[a&0xf];}
    
20. /////////////////////////////////////////////////////////////////////////////
    
21. // CHexEdit
    
22. #define DEMO 1
    
23. CHexEdit::CHexEdit()
    
24. {
    
25. #if !defined(DEMO)
    
26.         m_pData                        = NULL;                // pointer to data
    
27.         m_length                = 0;                // length of data
    
28. #else
    
29.         m_pData                        = (LPBYTE)malloc(0x40);
    
30.         for(int i = 0; i < 0x40; i++)
    
31.                 m_pData[i] = i;
    
32. #endif
    
33.         m_length                = 0x40;
    
34.         m_topindex                = 0;
    
35.         m_bpr                        = 8;                // byte per row
    
36.         m_lpp                        = 1;
    
37. 
    
38.         m_bShowHex                = TRUE;
    
39.         m_bShowAscii        = TRUE;
    
40.         m_bShowAddress        = TRUE;
    
41.         m_bAddressIsWide= TRUE;                // 4/8 byte address
    
42. 
    
43.         m_offAddress        = 0;
    
44.         m_offHex                = 0;
    
45.         m_offAscii                = 0;
    
46. 
    
47.         m_bUpdate = TRUE;                        // update font info
    
48.         m_bNoAddressChange = FALSE;
    
49.         m_currentMode = EDIT_NONE;
    
50. 
    
51.         m_editPos.x = m_editPos.y = 0;
    
52.         m_currentAddress = 0;
    
53.         m_bHalfPage = TRUE;
    
54. 
    
55.         m_selStart        = 0xffffffff;
    
56.         m_selEnd        = 0xffffffff;
    
57. 
    
58.         m_Font.CreateFont(-12, 0,0,0,0,0,0,0,0,0,0,0,0, "Courier New");
    
59. 
    
60.         AfxOleInit();
    
61. }
    
62. 
    
63. CHexEdit::~CHexEdit()
    
64. {
    
65. }
    
66. 
    
67. 
    
68. BEGIN_MESSAGE_MAP(CHexEdit, CEdit)
    
69.         ON_WM_CONTEXTMENU()
    
70.         //{{AFX_MSG_MAP(CHexEdit)
    
71.         ON_WM_CHAR()
    
72.         ON_WM_KILLFOCUS()
    
73.         ON_WM_PAINT()
    
74.         ON_WM_SETFOCUS()
    
75.         ON_WM_SIZE()
    
76.         ON_WM_VSCROLL()
    
77.         ON_WM_HSCROLL()
    
78.         ON_WM_GETDLGCODE()
    
79.         ON_WM_ERASEBKGND()
    
80.         ON_WM_LBUTTONDOWN()
    
81.         ON_WM_LBUTTONDBLCLK()
    
82.         ON_WM_MOUSEMOVE()
    
83.         ON_WM_LBUTTONUP()
    
84.         ON_WM_KEYDOWN()
    
85.         ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
    
86.         ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
    
87.         ON_COMMAND(ID_EDIT_CUT, OnEditCut)
    
88.         ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
    
89.         ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
    
90.         ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
    
91.         //}}AFX_MSG_MAP
    
92. END_MESSAGE_MAP()
    
93. 
    
94. /////////////////////////////////////////////////////////////////////////////
    
95. // CHexEdit message handlers
    
96. 
    
97. 
    
98. void CHexEdit::OnPaint()
    
99. {
    
100.         CPaintDC pdc(this); // device context for painting
     
101. 
     
102.         CRect rc;
     
103.         GetClientRect(rc);
     
104.        
     
105.         CDC        dc;
     
106.         dc.CreateCompatibleDC(CDC::FromHandle(pdc.m_ps.hdc));
     
107.         CBitmap bm;
     
108. 
     
109.         bm.CreateCompatibleBitmap(CDC::FromHandle(pdc.m_ps.hdc), rc.Width(), rc.Height());
     
110.         dc.SelectObject(bm);
     
111. 
     
112.         CBrush b;
     
113.         b.CreateSolidBrush(RGB(0xff,0xff,0xff));
     
114.         dc.FillRect(rc, &b);
     
115. 
     
116.         ASSERT(m_currentAddress >= 0);
     
117.         ASSERT(m_topindex >= 0);
     
118. 
     
119.         dc.SelectObject(m_Font);
     
120.         int                height                = 0;
     
121.         int                x,y;
     
122.         char        buf[256];
     
123. 
     
124.         x = rc.TopLeft().x;
     
125.         y = rc.TopLeft().y;
     
126. 
     
127.         dc.SetBoundsRect(&rc, DCB_DISABLE);
     
128. 
     
129.         if(m_pData)
     
130.         {
     
131.                 //
     
132.                 // get char dimensions
     
133.                 //
     
134.                 if(m_bUpdate)
     
135.                 {
     
136.                         dc.GetCharWidth('0', '0', &m_nullWidth);
     
137.                         CSize sz = dc.GetTextExtent("0", 1);
     
138.                         m_lineHeight = sz.cy;
     
139.                        
     
140.                         m_offHex        = m_bShowAddress ? (m_bAddressIsWide ? m_nullWidth * 9 : m_nullWidth * 5) : 0;
     
141.                         m_offAscii        = m_bShowAddress ? (m_bAddressIsWide ? m_nullWidth * 9 : m_nullWidth * 5) : 0;
     
142.                         m_offAscii += m_bShowHex         ? (m_bpr * 3 * m_nullWidth) : 0;
     
143. 
     
144.                         m_lpp = rc.Height() / m_lineHeight;
     
145.                         m_bHalfPage = FALSE;
     
146.                         if(m_lpp * m_bpr > m_length)
     
147.                         {
     
148.                                 m_lpp = (m_length + (m_bpr/2)) / m_bpr ;
     
149.                                 if(m_length % m_bpr != 0)
     
150.                                 {
     
151.                                         m_bHalfPage = TRUE;
     
152.                                         m_lpp++;
     
153.                                 }
     
154.                         }
     
155.                         m_bUpdate = FALSE;
     
156.                         UpdateScrollbars();
     
157.                 }
     
158. 
     
159.                 TRACE("%i %i\n", m_topindex, m_selStart);
     
160.                
     
161.                 height = rc.Height() / m_lineHeight;
     
162.                 height *= m_lineHeight;
     
163. 
     
164.                 if(m_bShowAddress)
     
165.                 {
     
166.                         char fmt[8] = {'%','0','8','l','X'};
     
167.                         fmt[2] = m_bAddressIsWide ? '8' : '4';
     
168.                         int w = m_bAddressIsWide ? 8 : 4;
     
169.                         y = 0;
     
170.                         CRect rcd = rc;
     
171.                         rcd.TopLeft().x = m_offAddress;
     
172.                         for(int         i = m_topindex; (i < m_length) && (rcd.TopLeft().y < height); i+= m_bpr)
     
173.                         {
     
174.                                 sprintf(buf, fmt, i);
     
175.                                 dc.DrawText(buf, w, rcd, DT_LEFT|DT_TOP|DT_SINGLELINE|DT_NOPREFIX);
     
176.                                 rcd.TopLeft().y += m_lineHeight;
     
177.                         }
     
178.                 }
     
179.                 if(m_bShowHex)
     
180.                 {
     
181.                         y = 0;
     
182.                         CRect rcd = rc;
     
183.                         rcd.TopLeft().x = x = m_offHex;
     
184. 
     
185.                         if(m_selStart != 0xffffffff && (m_currentMode == EDIT_HIGH || m_currentMode == EDIT_LOW))
     
186.                         {
     
187.                                 int         i;
     
188.                                 int         n = 0;
     
189.                                 int         selStart = m_selStart, selEnd = m_selEnd;
     
190.                                 if(selStart > selEnd)
     
191.                                         selStart ^= selEnd ^= selStart ^= selEnd;
     
192. 
     
193.                                 for(i = m_topindex; (i < selStart) && (y < height); i++)
     
194.                                 {
     
195.                                         char* p = &buf[0];
     
196.                                         TOHEX(m_pData[i], p);
     
197.                                         *p++ = ' ';
     
198.                                         dc.TextOut(x, y, buf, 3);
     
199.                                         x += m_nullWidth * 3;
     
200.                                         n++;
     
201.                                         if(n == m_bpr)
     
202.                                         {
     
203.                                                 n = 0;
     
204.                                                 x = m_offHex;
     
205.                                                 y += m_lineHeight;
     
206.                                         }
     
207.                                 }
     
208.                                 dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
     
209.                                 dc.SetBkColor(GetSysColor(COLOR_HIGHLIGHT));
     
210.                                 for(; (i < selEnd) && (i < m_length) && (y < height); i++)
     
211.                                 {
     
212.                                         char* p = &buf[0];
     
213.                                         TOHEX(m_pData[i], p);
     
214.                                         *p++ = ' ';
     
215.                                         dc.TextOut(x, y, buf, 3);
     
216.                                         x += m_nullWidth * 3;
     
217.                                         n++;
     
218.                                         if(n == m_bpr)
     
219.                                         {
     
220.                                                 n = 0;
     
221.                                                 x = m_offHex;
     
222.                                                 y += m_lineHeight;
     
223.                                         }
     
224.                                 }
     
225.                                 dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
     
226.                                 dc.SetBkColor(GetSysColor(COLOR_WINDOW));
     
227.                                 for(; (i < m_length) && (y < height); i++)
     
228.                                 {
     
229.                                         char* p = &buf[0];
     
230.                                         TOHEX(m_pData[i], p);
     
231.                                         *p++ = ' ';
     
232.                                         dc.TextOut(x, y, buf, 3);
     
233.                                         x += m_nullWidth * 3;
     
234.                                         n++;
     
235.                                         if(n == m_bpr)
     
236.                                         {
     
237.                                                 n = 0;
     
238.                                                 x = m_offHex;
     
239.                                                 y += m_lineHeight;
     
240.                                         }
     
241.                                 }
     
242.                         }
     
243.                         else
     
244.                         {
     
245.                                 for(int         i = m_topindex; (i < m_length) && (rcd.TopLeft().y < height);)
     
246.                                 {
     
247.                                         char* p = &buf[0];
     
248.                                         for(int         n = 0; (n < m_bpr) && (i < m_length); n++)
     
249.                                         {
     
250.                                                 TOHEX(m_pData[i], p);
     
251.                                                 *p++ = ' ';
     
252.                                                 i++;
     
253.                                         }
     
254.                                         while(n < m_bpr)
     
255.                                         {
     
256.                                                 *p++ = ' ';        *p++ = ' ';        *p++ = ' ';
     
257.                                                 n++;
     
258.                                         }
     
259. 
     
260.                                         dc.DrawText(buf, m_bpr*3, rcd, DT_LEFT|DT_TOP|DT_SINGLELINE|DT_NOPREFIX);
     
261.                                         rcd.TopLeft().y += m_lineHeight;
     
262.                                 }
     
263.                         }
     
264.                 }
     
265.                 if(m_bShowAscii)
     
266.                 {
     
267.                         y = 0;
     
268.                         CRect rcd = rc;
     
269.                         rcd.TopLeft().x = x = m_offAscii;
     
270.                         if(m_selStart != 0xffffffff && m_currentMode == EDIT_ASCII)
     
271.                         {
     
272.                                 int         i;
     
273.                                 int         n = 0;
     
274.                                 int         selStart = m_selStart, selEnd = m_selEnd;
     
275.                                 if(selStart > selEnd)
     
276.                                         selStart ^= selEnd ^= selStart ^= selEnd;
     
277. 
     
278.                                 for(i = m_topindex; (i < selStart) && (y < height); i++)
     
279.                                 {
     
280.                                         buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
     
281.                                         dc.TextOut(x, y, buf, 1);
     
282.                                         x += m_nullWidth;
     
283.                                         n++;
     
284.                                         if(n == m_bpr)
     
285.                                         {
     
286.                                                 n = 0;
     
287.                                                 x = m_offAscii;
     
288.                                                 y += m_lineHeight;
     
289.                                         }
     
290.                                 }
     
291.                                 dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
     
292.                                 dc.SetBkColor(GetSysColor(COLOR_HIGHLIGHT));
     
293.                                 for(; (i < selEnd) && (y < height); i++)
     
294.                                 {
     
295.                                         buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
     
296.                                         dc.TextOut(x, y, buf, 1);
     
297.                                         x += m_nullWidth;
     
298.                                         n++;
     
299.                                         if(n == m_bpr)
     
300.                                         {
     
301.                                                 n = 0;
     
302.                                                 x = m_offAscii;
     
303.                                                 y += m_lineHeight;
     
304.                                         }
     
305.                                 }
     
306.                                 dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
     
307.                                 dc.SetBkColor(GetSysColor(COLOR_WINDOW));
     
308.                                 for(; (i < m_length) && y < height; i++)
     
309.                                 {
     
310.                                         buf[0] = isprint(m_pData[i]) ? m_pData[i] : '.';
     
311.                                         dc.TextOut(x, y, buf, 1);
     
312.                                         x += m_nullWidth;
     
313.                                         n++;
     
314.                                         if(n == m_bpr)
     
315.                                         {
     
316.                                                 n = 0;
     
317.                                                 x = m_offAscii;
     
318.                                                 y += m_lineHeight;
     
319.                                         }
     
320.                                 }
     
321.                         }
     
322.                         else
     
323.                         {
     
324.                                 for(int         i = m_topindex; (i < m_length) && (rcd.TopLeft().y < height);)
     
325.                                 {
     
326.                                         char* p = &buf[0];
     
327.                                         for(int         n = 0; (n < m_bpr) && (i < m_length); n++)
     
328.                                         {
     
329.                                                 *p++ = isprint(m_pData[i]) ? m_pData[i] : '.';
     
330.                                                 i++;
     
331.                                         }
     
332.                                         dc.DrawText(buf, n, rcd, DT_LEFT|DT_TOP|DT_SINGLELINE|DT_NOPREFIX);
     
333.                                         rcd.TopLeft().y += m_lineHeight;
     
334.                                 }
     
335.                         }
     
336.                 }
     
337.         }
     
338.         pdc.BitBlt(0, 0, rc.Width(), rc.Height(), &dc, 0, 0, SRCCOPY);
     
339. }
     
340. 
     
341. void CHexEdit::OnSetFocus(CWnd* pOldWnd)
     
342. {
     
343.         if(m_pData && !IsSelected())
     
344.         {
     
345.                 if(m_editPos.x == 0 && m_bShowAddress)
     
346.                         CreateAddressCaret();
     
347.                 else
     
348.                         CreateEditCaret();
     
349.                 SetCaretPos(m_editPos);
     
350.                 ShowCaret();
     
351.         }
     
352.         CWnd::OnSetFocus(pOldWnd);
     
353. }
     
354. 
     
355. void CHexEdit::OnKillFocus(CWnd* pNewWnd)
     
356. {
     
357.         DestroyCaret();
     
358.         CWnd::OnKillFocus(pNewWnd);
     
359. }
     
360. 
     
361. void CHexEdit::OnSize(UINT nType, int cx, int cy)
     
362. {
     
363.         CEdit::OnSize(nType, cx, cy);
     
364. }
     
365. 
     
366. void CHexEdit::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
     
367. {
     
368.         pScrollBar;
     
369.         if(!m_pData)
     
370.                 return;
     
371. 
     
372.         int oa = m_topindex;
     
373.         switch(nSBCode)
     
374.         {
     
375.                 case SB_LINEDOWN:
     
376.                         if(m_topindex < m_length - m_lpp*m_bpr)
     
377.                         {
     
378.                                 //ScrollWindow(0, -m_lineHeight, rc);
     
379.                                 m_topindex += m_bpr;
     
380.                                 RedrawWindow();
     
381.                         }
     
382.                         break;
     
383.                
     
384.                 case SB_LINEUP:
     
385.                         if(m_topindex > 0)
     
386.                         {
     
387.                                 //ScrollWindow(0, m_lineHeight, rc);
     
388.                                 m_topindex -= m_bpr;
     
389.                                 RedrawWindow();
     
390.                         }
     
391.                         break;
     
392.                
     
393.                 case SB_PAGEDOWN:
     
394.                         if(m_topindex < m_length - m_lpp*m_bpr)
     
395.                         {
     
396.                                 m_topindex += m_bpr * m_lpp;
     
397.                                 if(m_topindex > m_length - m_lpp*m_bpr)
     
398.                                         m_topindex = m_length - m_lpp*m_bpr;
     
399.                                 RedrawWindow();
     
400.                         }
     
401.                         break;
     
402. 
     
403.                 case SB_PAGEUP:
     
404.                         if(m_topindex > 0)
     
405.                         {
     
406.                                 m_topindex -= m_bpr * m_lpp;
     
407.                                 if(m_topindex < 0)
     
408.                                         m_topindex = 0;
     
409.                                 RedrawWindow();
     
410.                         }
     
411.                         break;
     
412. 
     
413.                 case SB_THUMBTRACK:
     
414.                         m_topindex = nPos * m_bpr;
     
415.                         RedrawWindow();
     
416.                         break;
     
417.         }
     
418.         ::SetScrollPos(this->m_hWnd, SB_VERT, m_topindex / m_bpr, TRUE);
     
419.         if(!m_bNoAddressChange)
     
420.                 m_currentAddress += (m_topindex - oa);
     
421.         RepositionCaret(m_currentAddress);
     
422. }
     
423. 
     
424. void CHexEdit::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
     
425. {
     
426.         nSBCode;nPos; pScrollBar;
     
427. }
     
428. 
     
429. UINT CHexEdit::OnGetDlgCode()
     
430. {
     
431.         return DLGC_WANTALLKEYS;
     
432. }
     
433. 
     
434. BOOL CHexEdit::PreCreateWindow(CREATESTRUCT& cs)
     
435. {
     
436.         cs.style |= WS_HSCROLL|WS_VSCROLL;
     
437.         return CEdit::PreCreateWindow(cs);
     
438. }
     
439. 
     
440. BOOL CHexEdit::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
     
441. {
     
442.         dwStyle |= WS_HSCROLL|WS_VSCROLL;
     
443.         BOOL bRet = CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
     
444.         if(bRet)
     
445.                 SetFont(&m_Font);
     
446.         return bRet;
     
447. }
     
448. 
     
449. BOOL CHexEdit::OnEraseBkgnd(CDC* pDC)
     
450. {
     
451.         pDC;
     
452.         return TRUE;
     
453. }
     
454. 
     
455. void CHexEdit::SetOptions(BOOL a, BOOL h, BOOL c, BOOL w)
     
456. {
     
457.         m_bShowHex                = h;
     
458.         m_bShowAscii        = c;
     
459.         m_bShowAddress        = a;
     
460.         m_bAddressIsWide= w;                // 4/8 byte address
     
461.         m_bUpdate                = TRUE;
     
462. }
     
463. 
     
464. void CHexEdit::SetBPR(int bpr)
     
465. {
     
466.         m_bpr = bpr;
     
467.         m_bUpdate                = TRUE;
     
468. }
     
469. 
     
470. void CHexEdit::OnLButtonDown(UINT nFlags, CPoint point)
     
471. {
     
472.         SetFocus();
     
473.         if(!m_pData)
     
474.                 return;
     
475. 
     
476.         if(nFlags & MK_SHIFT)
     
477.         {
     
478.                 m_selStart = m_currentAddress;
     
479.         }
     
480.         CPoint pt = CalcPos(point.x, point.y);
     
481.         if(pt.x > -1)
     
482.         {
     
483.                 m_editPos = pt;
     
484.                 pt.x *= m_nullWidth;
     
485.                 pt.y *= m_lineHeight;
     
486.                
     
487.                 if(pt.x == 0 && m_bShowAddress)
     
488.                         CreateAddressCaret();
     
489.                 else
     
490.                         CreateEditCaret();
     
491. 
     
492.                 SetCaretPos(pt);
     
493.                 if(nFlags & MK_SHIFT)
     
494.                 {
     
495.                         m_selEnd = m_currentAddress;
     
496.                         if(m_currentMode == EDIT_HIGH || m_currentMode == EDIT_LOW)
     
497.                                 m_selEnd++;
     
498.                         RedrawWindow();
     
499.                 }
     
500.         }
     
501.         if(!(nFlags & MK_SHIFT))
     
502.         {
     
503.                 if(DragDetect(this->m_hWnd, point))
     
504.                 {
     
505.                         m_selStart = m_currentAddress;
     
506.                         m_selEnd   = m_selStart;
     
507.                         SetCapture();
     
508.                 }
     
509.                 else
     
510.                 {
     
511.                         BOOL bsel = m_selStart != 0xffffffff;
     
512. 
     
513.                         m_selStart = 0xffffffff;
     
514.                         m_selEnd   = 0xffffffff;
     
515.                         if(bsel)
     
516.                                 RedrawWindow();
     
517.                 }
     
518.         }
     
519.         if(!IsSelected())
     
520.         {
     
521.                 ShowCaret();
     
522.         }
     
523. }
     
524. 
     
525. void CHexEdit::OnLButtonDblClk(UINT nFlags, CPoint point)
     
526. {
     
527.         nFlags; point;
     
528. }
     
529. 
     

复制代码