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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
hexviewView.cpp
资源名称：hvcode.zip　[点击查看]
上传用户：ycdyang2
上传日期：2007-01-07
资源大小：126k
文件大小：19k
源码类别：

编辑器/阅读器

开发平台：

Visual C++

hexviewView.cpp：源码内容
  1. /* ---------------------------------------------------------------------------
  3.    This code can be used as you wish but without warranties as to performance 
  4.    of merchantability or any other warranties whether expressed or implied.
  5.    
  6.  Written by Mike Funduc, Funduc Software Inc. 8/1/96
  8.  To download the code and more useful utilities (including Search and
  9.  Replace for Windows 95/NT, 3.1x) go to:
  10.  http://www.funduc.com
  12. ----------------------------------------------------------------------------*/
  14. // hexviewView.cpp : implementation of the CHexviewView class
  15. //
  17. #include "stdafx.h"
  18. #include "hexview.h"
  20. #include "hexviewDoc.h"
  21. #include "hexviewView.h"
  22. #include "gotodlg.h"
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. extern BOOL bDBCS;
  32. /////////////////////////////////////////////////////////////////////////////
  33. // CHexviewView
  35. IMPLEMENT_DYNCREATE(CHexviewView, CScrollView)
  37. BEGIN_MESSAGE_MAP(CHexviewView, CScrollView)
  38. //{{AFX_MSG_MAP(CHexviewView)
  39. ON_WM_DESTROY()
  40. ON_WM_VSCROLL()
  41. ON_WM_KEYDOWN()
  42. ON_WM_SIZE()
  43. ON_COMMAND(ID_VIEW_NEXTBLOCK, OnViewNextblock)
  44. ON_COMMAND(ID_VIEW_PREVIOUSBLOCK, OnViewPreviousblock)
  45. ON_UPDATE_COMMAND_UI(ID_VIEW_NEXTBLOCK, OnUpdateViewNextblock)
  46. ON_UPDATE_COMMAND_UI(ID_VIEW_PREVIOUSBLOCK, OnUpdateViewPreviousblock)
  47. ON_COMMAND(ID_VIEW_GOTO, OnViewGoto)
  48. //}}AFX_MSG_MAP
  49. // Standard printing commands
  50. ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
  51. ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
  52. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
  53. END_MESSAGE_MAP()
  55. /////////////////////////////////////////////////////////////////////////////
  56. // CHexviewView construction/destruction
  58. CHexviewView::CHexviewView()
  59. {
  60.     m_cfFixedFont = new(CFont);
  61. if (bDBCS)
  62. m_cfFixedFont->CreateStockObject(SYSTEM_FIXED_FONT);
  63. else
  64. m_cfFixedFont->CreateStockObject(ANSI_FIXED_FONT);
  65. m_cfBoldFont = new CFont;
  66.     // try and create the new font for the list box
  67.     // it should be the same as the old but without the BOLD weight
  68.     LOGFONT oldFont;
  69.     m_cfFixedFont->GetObject(sizeof(LOGFONT), &oldFont);
  70.     
  71. oldFont.lfUnderline = TRUE;
  73.     m_cfBoldFont->CreateFontIndirect(&oldFont);
  74.     m_cfPrintFont = NULL;
  75.     m_cfPrintBoldFont = NULL;
  77. m_iCurrentOffset = 0;
  79. }
  81. CHexviewView::~CHexviewView()
  82. {
  83. delete m_cfBoldFont;
  84. delete m_cfPrintFont;
  85. delete m_cfPrintBoldFont;
  86. }
  88. /////////////////////////////////////////////////////////////////////////////
  89. // CHexviewView drawing
  91. void CHexviewView::OnDraw(CDC* pDC)
  92. {
  93. CHexviewDoc* pDoc = GetDocument();
  94. ASSERT_VALID(pDoc);
  96. DispData(pDC, m_iFirstLine, pDoc->TotalFileLength(), m_cfFixedFont,
  97. m_cfBoldFont, m_iWndLines, m_iFontHeight, m_iCurrentOffset, m_iFontWidth);
  98. }
  100. void CHexviewView::DispData(CDC* pDC, int iFirstLine, int iTotalLines, 
  101. CFont *cfFixedFont, CFont *cfBoldFont,
  102. int iWndLines, int iFontHeight, int iCurrentOffset, 
  103. int iFontWidth, int iLine)
  104. {
  105.     CFont *pOldFont = pDC->SelectObject(cfFixedFont);
  107.     CRect rcWnd;
  108.     GetClientRect(&rcWnd);
  110.     // compute the start point
  111.     int iOffset = iFirstLine * 16 + iCurrentOffset;
  112.     int iRemaining = iTotalLines - iOffset;
  113.     CHexviewDoc* pDoc = GetDocument();
  114.     BYTE *pData = pDoc->AdjustPointerAbsolute(0);
  115. bool bIgnoreThisChar = false;
  117. int x=0;
  118.     if (!pData) 
  119. {
  120.         pDC->TextOut(0, 0, "No data", 7);
  121.     } 
  122. else 
  123. {
  124.         char buf[100], buf2[100];
  125.         while ((iRemaining > 0) && (iLine < iWndLines)) 
  126. {
  127.             sprintf(buf, "%8.8lX  ", iOffset);
  128.             BYTE *p = pData + iOffset;
  129.             int iCount = iRemaining;
  130.             for (int i = 0; i < 16; i++) 
  131. {
  132.                 if (iCount > 0) 
  133. {
  134.                     sprintf(&buf[strlen(buf)],
  135.                             "%2.2X ",
  136.                             *p);
  137.                 } 
  138. else 
  139. {
  140.                     strcat(buf, "   ");
  141.                 }
  142.                 iCount--;
  143.                 p++;
  144.             }
  145.             strcat(buf, "  ");
  146.             p = pData + iOffset;
  147.             iCount = iRemaining;
  148.             for (i = 0; i < 16; i++) 
  149. {
  150. // If bIgnoreThisChar is true, this is that case that last line endded
  151. // with lead byte of double byte char and the value of this tail byte 
  152. // is in the range  of lead byte. Yuk!
  154. // If this is double byte char, need to deal with it now!
  155. // IsDBCSLeadByte() may return TRUE for tail byte if its value is
  156. // in the range of lead bytes'
  157.                 if ((bDBCS) && (IsDBCSLeadByte(*p)) && !bIgnoreThisChar)
  158.                 {
  159. sprintf(&buf[strlen(buf)], "%c%c", *p, *(p + 1));
  160. iCount-=2;
  161. p+=2;
  162. i++;
  163. if (i >= 16)
  164. bIgnoreThisChar = true;
  165.                 continue;
  166.                 }
  167.                 if ((iCount > 0) && isprint(*p) && !bIgnoreThisChar) 
  168. {
  169.                     sprintf(&buf[strlen(buf)], "%c", *p);
  170.                 } 
  171. else if (iCount > 0) 
  172. {
  173.                     strcat(buf, ".");
  174.                 } 
  175. else 
  176. {
  177.                     strcat(buf, " ");
  178.                 }
  179. bIgnoreThisChar = false;
  180.                 iCount--;
  181.                 p++;
  182.             }
  184. // Need to blank out rest of this line
  185. // This is to make all lines same length, otherwise, list control will have junk displayed.
  186. #define LINE_LENGTH 78
  187. if ((i = strlen(buf)) < LINE_LENGTH)
  188. {
  189. memset(&buf[i], ' ', LINE_LENGTH-i);
  190. buf[LINE_LENGTH]=0;
  191. }
  193. if ((iOffset + 16 >= pDoc->m_lStartOffset) && (iOffset < pDoc->m_lEndOffset))
  194. {
  195. strcpy(buf2, buf);
  196. CSize szExtent;
  197. int nStartOnLine = max(0, pDoc->m_lStartOffset - iOffset);
  198. int nItemsOnLine = min(pDoc->m_lEndOffset, iOffset + 16) - max(pDoc->m_lStartOffset, iOffset);
  199. // Characters before highlight
  200. pDC->TextOut(0, iLine * iFontHeight, buf, nStartOnLine * 3 + 10);
  201. szExtent = pDC->GetTextExtent(buf, nStartOnLine * 3 + 10);
  202. memcpy(buf, buf2 + nStartOnLine * 3 + 10, (16 - nStartOnLine) * 3 + 2);
  203. buf[(16 - nStartOnLine) * 3 + 2] = 0;
  204. pDC->SelectObject(cfBoldFont);
  205. // Highlight characters
  206. pDC->TextOut(szExtent.cx, iLine * iFontHeight, buf, nItemsOnLine * 3);
  207. szExtent += pDC->GetTextExtent(buf, nItemsOnLine * 3);
  208. pDC->SelectObject(cfFixedFont);
  209. strcpy(buf, buf2 + (nStartOnLine + nItemsOnLine) * 3 + 10);
  210. // Characters after highlight
  211. pDC->TextOut(szExtent.cx, iLine * iFontHeight, buf, strlen(buf));
  212. pDC->MoveTo(0, (iLine + 1) * iFontHeight);
  213. }
  214. else  // Just a regular line
  215. pDC->TextOut(0, iLine * iFontHeight, buf, strlen(buf));
  216.             iOffset += 16;
  217.             iRemaining -= 16;
  218.             iLine++;
  219.         }
  220.         if (iLine < iWndLines) 
  221. {
  222.             CRect rc = rcWnd;
  223.             rc.top = iLine * iFontHeight;
  224.             pDC->ExtTextOut(0, iLine * iFontHeight, ETO_OPAQUE,
  225.                             &rc, "", 0, NULL);
  226.         }
  227.     }
  228.     pDC->SelectObject(pOldFont);
  229. }
  231. void CHexviewView::OnInitialUpdate()
  232. {
  233.     CDC *pDC = GetDC();
  234.     CFont *pOldFont = pDC->SelectObject(m_cfFixedFont);
  235.     pDC->SelectObject(pOldFont);
  236.     CHexviewDoc* pDoc = GetDocument();
  237.     m_iLastLine = 0;
  238.     m_iWndLines = 0;
  239. m_iFirstLine = 0;
  241. CScrollView::OnInitialUpdate();
  243. UpdateScrollSizes();
  244. if (pDoc->m_lStartOffset > -1)
  245. {
  246. if (pDoc->m_lStartOffset > pDoc->TotalFileLength())
  247. {
  248. m_iFirstLine = 0;
  249. pDoc->m_lStartOffset = pDoc->m_lEndOffset = -1;
  250. }
  251. else
  252. {
  253. while (pDoc->m_lStartOffset > m_iCurrentOffset + pDoc->BlockLength(m_iCurrentOffset))
  254. {
  255. pDoc->GetNextBlock(m_iCurrentOffset);
  256. }
  257. m_iFirstLine = (pDoc->m_lStartOffset - m_iCurrentOffset) / 16;
  258. m_iLastLine = (pDoc->BlockLength(m_iCurrentOffset) + 15) / 16;
  259. UpdateScrollSizes();
  260. }
  261. }
  262. }
  264. void CHexviewView::UpdateScrollSizes()
  265. {
  266. // UpdateScrollSizes() is called when it is necessary to adjust the
  267. // scrolling range or page/line sizes.  There are two occassions
  268. // where this is necessary:  (1) when a new row is added-- see
  269. // UpdateRow()-- and (2) when the window size changes-- see OnSize().
  270. CRect rectClient;
  271. GetClientRect(&rectClient);
  273. CClientDC dc(this);
  274.     TEXTMETRIC tm;
  275.     dc.GetTextMetrics(&tm);
  276.     m_iFontHeight = tm.tmHeight + tm.tmExternalLeading;
  277.     m_iFontWidth = tm.tmMaxCharWidth;
  279.     CSize sz;
  280.     sz.cx = m_iFontWidth * 80;
  281.     CHexviewDoc* pDoc = GetDocument();
  282.     sz.cy = m_iViewHeight = (pDoc->BlockLength(m_iCurrentOffset) + 15) / 16;
  284. m_iLastLine = m_iViewHeight;
  286. // The vert scrolling range is the total display height of all
  287. // of the rows.
  288. CSize sizeTotal(sz.cx,
  289. m_iFontHeight * (min(m_iViewHeight, INT_MAX / m_iFontHeight - 1)));
  291.     m_iWndLines = max(1, (rectClient.bottom/m_iFontHeight));
  292. // The vertical per-page scrolling distance is equal to the
  293. // how many rows can be displayed in the current window, less
  294. // one row for paging overlap.
  295. CSize sizePage(sz.cx, m_iWndLines * m_iFontHeight);
  297. // The vertical per-line scrolling distance is equal to the
  298. // height of the row.
  299. CSize sizeLine(sz.cx, m_iFontHeight);
  301. SetScrollSizes(MM_TEXT, sizeTotal, sizePage, sizeLine);
  303. if (sizePage.cy >= sizeTotal.cy)
  304. {
  305. m_iFirstLine = 0;
  306.     SetScrollPos(SB_VERT, 0, TRUE);
  307. }
  308. else
  309. {
  310.         int iPos = 0;
  311. if ((m_iLastLine - m_iWndLines) * m_iFontHeight)  // No divide by 0
  312. iPos = (m_iViewHeight * m_iFirstLine) / (m_iLastLine - m_iWndLines) * m_iFontHeight;
  313. SetScrollPos(SB_VERT, iPos, TRUE);
  314. }
  315. }
  317. /////////////////////////////////////////////////////////////////////////////
  318. // CHexviewView printing
  320. BOOL CHexviewView::OnPreparePrinting(CPrintInfo* pInfo)
  321. {
  322. // default preparation
  323. return DoPreparePrinting(pInfo);
  324. }
  326. HFONT hOldFont = NULL;
  328. void CHexviewView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  329. {
  330. // get current screen font object metrics
  331. CFont* pFont = GetFont();
  332. LOGFONT lf;
  333. LOGFONT lfSys;
  334. VERIFY(::GetObject(::GetStockObject(ANSI_FIXED_FONT), sizeof(LOGFONT),
  335. &lfSys));
  336. if (pFont)
  337. {
  338. VERIFY(pFont->GetObject(sizeof(LOGFONT), &lf));
  339. if (lstrcmpi((LPCTSTR)lf.lfFaceName, (LPCTSTR)lfSys.lfFaceName) == 0)
  340. return;
  341. lstrcpy(lf.lfFaceName, (LPCTSTR)lfSys.lfFaceName);
  342. }
  343. else
  344. {
  345. lf = lfSys;
  346. }
  347. // map to printer font metrics
  348. HDC hDCFrom = ::GetDC(NULL);
  349. lf.lfHeight = ::MulDiv(lf.lfHeight, pDC->GetDeviceCaps(LOGPIXELSY),
  350. ::GetDeviceCaps(hDCFrom, LOGPIXELSY));
  351. lf.lfWidth = ::MulDiv(lf.lfWidth, pDC->GetDeviceCaps(LOGPIXELSX),
  352. ::GetDeviceCaps(hDCFrom, LOGPIXELSX));
  353. ::ReleaseDC(NULL, hDCFrom);
  355. // create it, if it fails we just use the printer's default.
  356. if (m_cfPrintFont)
  357. delete m_cfPrintFont;
  358. if (m_cfPrintBoldFont)
  359. delete m_cfPrintBoldFont;
  360. m_cfPrintFont = new CFont;
  361. m_cfPrintBoldFont = new CFont;
  362. m_cfPrintFont->CreateFontIndirect(&lf);
  363. lf.lfUnderline = TRUE;
  365.     m_cfPrintBoldFont->CreateFontIndirect(&lf);
  367.     CFont *pOldFont = pDC->SelectObject(m_cfPrintFont);
  368.     TEXTMETRIC tm;
  369.     pDC->GetTextMetrics(&tm);
  370. int nPageHeight = pDC->GetDeviceCaps(VERTRES);
  371.     m_iFontHeight = tm.tmHeight + tm.tmExternalLeading;
  372. m_iWndLines = nPageHeight / m_iFontHeight - 5;
  374. CHexviewDoc* pDoc = GetDocument();
  375. ASSERT_VALID(pDoc);
  376. m_iFirstLine = 0;
  377. int nTotalLines = (pDoc->TotalFileLength() + 15) / 16;
  378. pInfo->SetMaxPage((nTotalLines + m_iWndLines - 1) / m_iWndLines);
  379. pDC->SelectObject(pOldFont);
  381. SYSTEMTIME sysTime;
  382. GetSystemTime(&sysTime);
  383. CString strDate;
  384. GetDateFormat(NULL, LOCALE_NOUSEROVERRIDE, &sysTime, NULL,
  385.           strDate.GetBuffer(255), 255);
  386. strDate.ReleaseBuffer();
  387. GetTimeFormat(NULL, LOCALE_NOUSEROVERRIDE, &sysTime, NULL,
  388.           m_strTimePrint.GetBuffer(255), 255);
  389. m_strTimePrint.ReleaseBuffer();
  390. m_strTimePrint = strDate + "  " + m_strTimePrint;
  391. }
  393. void CHexviewView::OnEndPrinting(CDC* pDC, CPrintInfo* /*pInfo*/)
  394. {
  395. UpdateScrollSizes();
  396. }
  398. /////////////////////////////////////////////////////////////////////////////
  399. // CHexviewView diagnostics
  401. #ifdef _DEBUG
  402. void CHexviewView::AssertValid() const
  403. {
  404. CScrollView::AssertValid();
  405. }
  407. void CHexviewView::Dump(CDumpContext& dc) const
  408. {
  409. CScrollView::Dump(dc);
  410. }
  412. CHexviewDoc* CHexviewView::GetDocument() // non-debug version is inline
  413. {
  414. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CHexviewDoc)));
  415. return (CHexviewDoc*)m_pDocument;
  416. }
  417. #endif //_DEBUG
  419. /////////////////////////////////////////////////////////////////////////////
  420. // CHexviewView message handlers
  422. void CHexviewView::OnDestroy() 
  423. {
  424. delete m_cfFixedFont;
  425. CScrollView::OnDestroy();
  426. }
  428. void CHexviewView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo) 
  429. {
  430. // TODO: Add your specialized code here and/or call the base class
  432. CScrollView::OnPrepareDC(pDC, pInfo);
  433.     CPoint pt = pDC->GetViewportOrg();
  434.     pt.y = 0;
  435.     pDC->SetViewportOrg(pt);
  437. }
  439. void CHexviewView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  440. {
  441.     switch (nSBCode) 
  442. {
  443.     case SB_TOP:
  444.         m_iFirstLine = 0;
  445.         break;
  446.     
  447.     case SB_BOTTOM:
  448.         m_iFirstLine = m_iLastLine;
  449.         break;
  450.     
  451.     case SB_LINEUP:
  452.         m_iFirstLine--;
  453.         break;
  454.         
  455.     case SB_PAGEUP:    
  456.         m_iFirstLine -= m_iWndLines;
  457.         break;
  459.     case SB_LINEDOWN:
  460.         m_iFirstLine++;
  461.         break;
  463.     case SB_PAGEDOWN:
  464.         m_iFirstLine += m_iWndLines;
  465.         break;
  466.     
  467.     case SB_THUMBPOSITION:
  468.     case SB_THUMBTRACK:
  469.         m_iFirstLine = (nPos * m_iLastLine) / (m_iFontHeight * m_iViewHeight);
  470.         if (m_iFirstLine == m_iLastLine - m_iWndLines - 1)
  471.             m_iFirstLine = m_iLastLine - m_iWndLines;
  472.         break;
  474.     default:
  475.         return;
  476.     }
  478. if (m_iFirstLine >= m_iLastLine - m_iWndLines) 
  479. {
  480.         m_iFirstLine = m_iLastLine - m_iWndLines;
  481.     }
  482.     if (m_iFirstLine < 0) m_iFirstLine = 0;
  483.     if (m_iWndLines >= m_iLastLine) 
  484. {
  485.         m_iFirstLine = 0;
  486.     } 
  488.     int iPos = 0;
  489.     if (m_iWndLines < m_iLastLine) 
  490.         iPos = ((m_iViewHeight * m_iFirstLine) / (m_iLastLine - m_iWndLines)) * m_iFontHeight;
  491. TRACE("First Line: %d, Last Line: %d, Window lines: %d, Position: %dn", 
  492. m_iFirstLine, m_iLastLine, m_iWndLines, iPos);
  493.     SetScrollPos(SB_VERT, iPos, TRUE);
  494.     Invalidate(TRUE);
  495. }
  497. void CHexviewView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  498. {
  499. // TODO: Add your message handler code here and/or call default
  501.    switch (nChar) 
  502.    {
  503.     case VK_HOME:
  504.         OnVScroll(SB_TOP, 0, NULL);
  505.         break;
  507.     case VK_END:
  508.         OnVScroll(SB_BOTTOM, 0, NULL);
  509.         break;
  511.     case VK_UP:
  512.         OnVScroll(SB_LINEUP, 0, NULL);
  513.         break;
  515.     case VK_DOWN:
  516.         OnVScroll(SB_LINEDOWN, 0, NULL);
  517.         break;
  519.     case VK_PRIOR:
  520.         OnVScroll(SB_PAGEUP, 0, NULL);
  521.         break;
  523.     case VK_NEXT:
  524.         OnVScroll(SB_PAGEDOWN, 0, NULL);
  525.         break;
  526.     
  527.     default:    
  528.         CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
  529.         break;
  530.     }
  531. }
  534. void CHexviewView::OnPrint(CDC* pDC, CPrintInfo* pInfo) 
  535. {
  536.     CFont *pOldFont = pDC->SelectObject(m_cfPrintFont);
  537. // get string to show as "filename" in header/footer
  538. LPCTSTR pszFileName = GetDocument()->GetPathName();
  539. if (pszFileName[0] == 0)
  540. pszFileName = GetDocument()->GetTitle();
  542. // go thru global CPageSetupDlg to format the header and footer
  543. CString strHeader;
  544. strHeader = pszFileName;
  545. CString strFooter;
  546. CHexviewDoc* pDoc = GetDocument();
  547. int nTotalLines = (pDoc->TotalFileLength() + 15) / 16;
  548. wsprintf(strFooter.GetBuffer(81), "Page %d of %d", pInfo->m_nCurPage,
  549. (nTotalLines + m_iWndLines - 1) / m_iWndLines);
  550. strFooter.ReleaseBuffer();
  552. TEXTMETRIC tm;
  553. pDC->GetTextMetrics(&tm);
  554. int cyChar = tm.tmHeight;
  555. CRect rectPage = pInfo->m_rectDraw;
  557. // draw and exclude space for header
  558. if (!strHeader.IsEmpty())
  559. {
  560. pDC->TextOut(rectPage.left, rectPage.top, strHeader);
  561. int nAlign = pDC->SetTextAlign(TA_NOUPDATECP | TA_RIGHT | TA_TOP);
  562. strHeader = _T("Printed by HexView: http://www.funduc.com");
  563. pDC->TextOut(rectPage.right, rectPage.top, strHeader);
  564. pDC->SetTextAlign(nAlign);
  565. rectPage.top += cyChar + cyChar / 4;
  566. pDC->MoveTo(rectPage.left, rectPage.top);
  567. pDC->LineTo(rectPage.right, rectPage.top);
  568. rectPage.top += cyChar / 4;
  569. pInfo->m_rectDraw.top = rectPage.top;
  570. }
  572. // allow space for footer
  573. if (!strFooter.IsEmpty())
  574. pInfo->m_rectDraw.bottom -= cyChar + cyChar/4 + cyChar/4;
  576. int nPageHeight = pDC->GetDeviceCaps(VERTRES);
  577.     int iFontHeight = tm.tmHeight + tm.tmExternalLeading;
  578.     int iFontWidth = tm.tmMaxCharWidth;
  579. int iWndLines = nPageHeight / iFontHeight - 5;
  580. int iFirstLine = (pInfo->m_nCurPage -1) * iWndLines;
  581. iFirstLine += (2 * (pInfo->m_nCurPage -1));
  582. // Print the rows for the current page.
  584. int yTopOfPage = (pInfo->m_nCurPage -1) * iWndLines
  585. * iFontHeight;
  587. ASSERT_VALID(pDoc);
  589. DispData(pDC, iFirstLine, pDoc->TotalFileLength(), m_cfPrintFont,
  590. m_cfPrintBoldFont, iWndLines + 4, iFontHeight, 0, iFontWidth, 2);
  592. // draw footer
  593. if (!strFooter.IsEmpty())
  594. {
  595. rectPage.bottom -= cyChar;
  596. pDC->TextOut(rectPage.left, rectPage.bottom, strFooter);
  597. int nAlign = pDC->SetTextAlign(TA_NOUPDATECP | TA_RIGHT | TA_TOP);
  598. pDC->TextOut(rectPage.right, rectPage.bottom, m_strTimePrint);
  599. pDC->SetTextAlign(nAlign);
  600. rectPage.bottom -= cyChar / 4;
  601. pDC->MoveTo(rectPage.left, rectPage.bottom);
  602. pDC->LineTo(rectPage.right, rectPage.bottom);
  603. rectPage.bottom -= cyChar / 4;
  604. }
  605.     pDC->SelectObject(pOldFont);
  606. }
  608. void CHexviewView::OnSize(UINT nType, int cx, int cy) 
  609. {
  610. UpdateScrollSizes();
  611. CScrollView::OnSize(nType, cx, cy);
  612. }
  615. void CHexviewView::OnViewNextblock() 
  616. {
  617. CHexviewDoc* pDoc = GetDocument();
  618. ASSERT_VALID(pDoc);
  619. if (pDoc->GetNextBlock(m_iCurrentOffset))
  620. {
  621. m_iFirstLine = 0;
  622. m_iLastLine = (pDoc->BlockLength(m_iCurrentOffset) + 15) / 16;
  623.     SetScrollPos(SB_VERT, 0, TRUE);
  624. UpdateScrollSizes();
  625. Invalidate();
  626. }
  627. }
  629. void CHexviewView::OnViewPreviousblock() 
  630. {
  631. CHexviewDoc* pDoc = GetDocument();
  632. ASSERT_VALID(pDoc);
  633. if (pDoc->GetPrevBlock(m_iCurrentOffset))
  634. {
  635. m_iFirstLine = 0;
  636. m_iLastLine = (pDoc->BlockLength(m_iCurrentOffset) + 15) / 16;
  637.     SetScrollPos(SB_VERT, 0, TRUE);
  638. UpdateScrollSizes();
  639. Invalidate();
  640. }
  641. }
  643. void CHexviewView::OnUpdateViewNextblock(CCmdUI* pCmdUI) 
  644. {
  645. CHexviewDoc* pDoc = GetDocument();
  646. ASSERT_VALID(pDoc);
  647. int iCurrentOffset = m_iCurrentOffset;
  648. pCmdUI->Enable(pDoc->GetNextBlock(iCurrentOffset));
  649. }
  651. void CHexviewView::OnUpdateViewPreviousblock(CCmdUI* pCmdUI) 
  652. {
  653. CHexviewDoc* pDoc = GetDocument();
  654. ASSERT_VALID(pDoc);
  655. int iCurrentOffset = m_iCurrentOffset;
  656. pCmdUI->Enable(pDoc->GetPrevBlock(iCurrentOffset));
  657. }
  660. void CHexviewView::OnViewGoto() 
  661. {
  662. CGotoDlg dlgGoto;
  663. CHexviewDoc* pDoc = GetDocument();
  664. ASSERT_VALID(pDoc);
  666. if (pDoc->m_lStartOffset != -1)  // Show the initial offset
  667. dlgGoto.m_lNewOffset = pDoc->m_lStartOffset;
  668. else  // Show the top of current block
  669. dlgGoto.m_lNewOffset = m_iCurrentOffset;
  670. if (dlgGoto.DoModal() == IDOK)
  671. {
  672. // Bogus offset
  673. if (dlgGoto.m_lNewOffset > pDoc->TotalFileLength())
  674. {
  675. m_iFirstLine = 0;
  676. }
  677. else
  678. {
  679. // Find the right block
  680. while (dlgGoto.m_lNewOffset > m_iCurrentOffset + pDoc->BlockLength(m_iCurrentOffset))
  681. {
  682. pDoc->GetNextBlock(m_iCurrentOffset);
  683. }
  684. m_iFirstLine = (dlgGoto.m_lNewOffset - m_iCurrentOffset) / 16;
  685. m_iLastLine = (pDoc->BlockLength(m_iCurrentOffset) + 15) / 16;
  686. UpdateScrollSizes();
  687. }
  688. Invalidate();
  689. }
  690. }