home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 4 Unleashed / Visual_Basic_4_Unleashed_SAMS_Publishing_1995.iso / tedevkit / ter_view.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-11  |  34.1 KB  |  1,038 lines
  1. // ter_view.cpp : Implementaion for the CTerView Class
  2. //
  3. // This class is derived from the CView class.  Therefore, if your
  4. // application derives a class from the CTerView class and adds it
  5. // to the template using CWinApp::AddDocTemplate, the framework
  6. // will call both the constructor and the 'Create' function.
  7. //
  8. // Sub Systems, Inc.
  9. // Copyright 1994.
  10. // 159 Main Street, #8C
  11. // Stoneham, MA 02180
  12. /////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "stdafx.h"
  15.  
  16. #include "ter_view.h"
  17. #include "ter_cmd.h"
  18. #include "ter_view.rch"
  19. #include "resource.h"
  20.  
  21. #ifdef _DEBUG
  22. #undef THIS_FILE
  23. static char BASED_CODE THIS_FILE[] = __FILE__;
  24. #endif
  25.  
  26. // CTerView
  27.  
  28. IMPLEMENT_DYNCREATE(CTerView,CView)
  29.  
  30. BEGIN_MESSAGE_MAP(CTerView, CView)
  31.         //{{AFX_MSG_MAP(CTerView)
  32.         ON_WM_PAINT()
  33.         ON_WM_CREATE()
  34.         ON_COMMAND(TID_COPY, OnEditCopy)
  35.         ON_COMMAND(TID_CUT, OnEditCut)
  36.         ON_COMMAND(TID_PASTE, OnEditPaste)
  37.         ON_UPDATE_COMMAND_UI(TID_COPY, OnUpdateEditCopy)
  38.         ON_UPDATE_COMMAND_UI(TID_CUT, OnUpdateEditCut)
  39.         ON_UPDATE_COMMAND_UI(TID_PASTE, OnUpdateEditPaste)
  40.         ON_COMMAND(TID_UNDO, OnEditUndo)
  41.         ON_UPDATE_COMMAND_UI(TID_UNDO, OnUpdateEditUndo)
  42.         ON_COMMAND(TID_EDIT_HDR_FTR, OnEditHdrFtr)
  43.         ON_UPDATE_COMMAND_UI(TID_EDIT_HDR_FTR, OnUpdateEditHdrFtr)
  44.         ON_COMMAND(TID_PRINT, OnFilePrint)
  45.         ON_UPDATE_COMMAND_UI(TID_PRINT, OnUpdateFilePrint)
  46.         ON_COMMAND(TID_PRINT_PREVIEW, CView::OnFilePrintPreview)
  47.         ON_UPDATE_COMMAND_UI(TID_PRINT_PREVIEW, OnUpdateFilePrintPreview)
  48.         ON_COMMAND(TID_BOLD_ON, OnFontBold)
  49.         ON_UPDATE_COMMAND_UI(TID_BOLD_ON, OnUpdateFontBold)
  50.         ON_COMMAND(TID_ULINED_ON, OnFontDoubleunderline)
  51.         ON_UPDATE_COMMAND_UI(TID_ULINED_ON, OnUpdateFontDoubleunderline)
  52.         ON_COMMAND(TID_FONTS, OnFontFonts)
  53.         ON_UPDATE_COMMAND_UI(TID_FONTS, OnUpdateFontFonts)
  54.         ON_COMMAND(TID_HIDDEN_ON, OnFontHidden)
  55.         ON_UPDATE_COMMAND_UI(TID_HIDDEN_ON, OnUpdateFontHidden)
  56.         ON_COMMAND(TID_ITALIC_ON, OnFontItalic)
  57.         ON_UPDATE_COMMAND_UI(TID_ITALIC_ON, OnUpdateFontItalic)
  58.         ON_COMMAND(TID_CHAR_NORMAL, OnFontNormal)
  59.         ON_UPDATE_COMMAND_UI(TID_CHAR_NORMAL, OnUpdateFontNormal)
  60.         ON_COMMAND(TID_PROTECT_ON, OnFontProtect)
  61.         ON_UPDATE_COMMAND_UI(TID_PROTECT_ON, OnUpdateFontProtect)
  62.         ON_COMMAND(TID_STRIKE_ON, OnFontStrikethrough)
  63.         ON_UPDATE_COMMAND_UI(TID_STRIKE_ON, OnUpdateFontStrikethrough)
  64.         ON_COMMAND(TID_SUBSCR_ON, OnFontSubscript)
  65.         ON_UPDATE_COMMAND_UI(TID_SUBSCR_ON, OnUpdateFontSubscript)
  66.         ON_COMMAND(TID_SUPSCR_ON, OnFontSuperscript)
  67.         ON_UPDATE_COMMAND_UI(TID_SUPSCR_ON, OnUpdateFontSuperscript)
  68.         ON_COMMAND(TID_ULINE_ON, OnFontUnderline)
  69.         ON_UPDATE_COMMAND_UI(TID_ULINE_ON, OnUpdateFontUnderline)
  70.         ON_COMMAND(TID_COLOR, OnFontColor)
  71.         ON_UPDATE_COMMAND_UI(TID_COLOR, OnUpdateFontColor)
  72.         ON_COMMAND(TID_BK_COLOR, OnFontBkColor)
  73.         ON_UPDATE_COMMAND_UI(TID_BK_COLOR, OnUpdateFontBkColor)
  74.         ON_COMMAND(TID_SHOW_HIDDEN, OnViewHiddentext)
  75.         ON_UPDATE_COMMAND_UI(TID_SHOW_HIDDEN, OnUpdateViewHiddentext)
  76.         ON_COMMAND(TID_PAGE_MODE, OnViewPagemode)
  77.         ON_UPDATE_COMMAND_UI(TID_PAGE_MODE, OnUpdateViewPagemode)
  78.         ON_COMMAND(TID_SHOW_PARA_MARK, OnViewParagraphmarker)
  79.         ON_UPDATE_COMMAND_UI(TID_SHOW_PARA_MARK, OnUpdateViewParagraphmarker)
  80.         ON_COMMAND(TID_RULER, OnViewRuler)
  81.         ON_UPDATE_COMMAND_UI(TID_RULER, OnUpdateViewRuler)
  82.         ON_COMMAND(TID_SHOW_HYPERLINK_CURSOR, OnViewHyperlinkCursor)
  83.         ON_UPDATE_COMMAND_UI(TID_SHOW_HYPERLINK_CURSOR, OnUpdateViewHyperlinkCursor)
  84.         ON_COMMAND(TID_VIEW_HDR_FTR, OnViewHdrFtr)
  85.         ON_UPDATE_COMMAND_UI(TID_VIEW_HDR_FTR, OnUpdateViewHdrFtr)
  86.  
  87.         ON_COMMAND(TID_COL_BREAK, OnInsertColumnbreak)
  88.         ON_UPDATE_COMMAND_UI(TID_COL_BREAK, OnUpdateInsertColumnbreak)
  89.         ON_COMMAND(TID_PAGE_BREAK, OnInsertPagebreak)
  90.         ON_UPDATE_COMMAND_UI(TID_PAGE_BREAK, OnUpdateInsertPagebreak)
  91.         ON_COMMAND(TID_SECT_BREAK, OnInsertSectionbreak)
  92.         ON_UPDATE_COMMAND_UI(TID_SECT_BREAK, OnUpdateInsertSectionbreak)
  93.         ON_COMMAND(TID_INSERT_OBJECT, OnInsertObject)
  94.         ON_UPDATE_COMMAND_UI(TID_INSERT_OBJECT, OnUpdateInsertObject)
  95.         ON_COMMAND(TID_PICT_FROM_FILE, OnInsertPicture)
  96.         ON_UPDATE_COMMAND_UI(TID_PICT_FROM_FILE, OnUpdateInsertPicture)
  97.         ON_COMMAND(TID_BLOCK_COPY, OnBlockCopy)
  98.         ON_UPDATE_COMMAND_UI(TID_BLOCK_COPY, OnUpdateBlockCopy)
  99.         ON_COMMAND(TID_BLOCK_MOVE, OnBlockMove)
  100.         ON_UPDATE_COMMAND_UI(TID_BLOCK_MOVE, OnUpdateBlockMove)
  101.         ON_COMMAND(TID_DEL_LINE, OnDelLine)
  102.         ON_UPDATE_COMMAND_UI(TID_DEL_LINE, OnUpdateDelLine)
  103.         ON_COMMAND(TID_EDIT_PICT, OnEditPict)
  104.         ON_UPDATE_COMMAND_UI(TID_EDIT_PICT, OnUpdateEditPict)
  105.         ON_COMMAND(TID_INS_AFT, OnInsAft)
  106.         ON_UPDATE_COMMAND_UI(TID_INS_AFT, OnUpdateInsAft)
  107.         ON_COMMAND(TID_INS_BEF, OnInsBef)
  108.         ON_UPDATE_COMMAND_UI(TID_INS_BEF, OnUpdateInsBef)
  109.         ON_COMMAND(TID_JOIN_LINE, OnJoinLine)
  110.         ON_UPDATE_COMMAND_UI(TID_JOIN_LINE, OnUpdateJoinLine)
  111.         ON_COMMAND(TID_PASTE_SPEC, OnPasteSpec)
  112.         ON_UPDATE_COMMAND_UI(TID_PASTE_SPEC, OnUpdatePasteSpec)
  113.         ON_COMMAND(TID_REPAGINATE, OnRepaginate)
  114.         ON_UPDATE_COMMAND_UI(TID_REPAGINATE, OnUpdateRepaginate)
  115.         ON_COMMAND(TID_SECT_OPTIONS, OnSectOptions)
  116.         ON_UPDATE_COMMAND_UI(TID_SECT_OPTIONS, OnUpdateSectOptions)
  117.         ON_COMMAND(TID_SELECT_ALL, OnSelectAll)
  118.         ON_UPDATE_COMMAND_UI(TID_SELECT_ALL, OnUpdateSelectAll)
  119.         ON_COMMAND(TID_SPLIT_LINE, OnSplitLine)
  120.         ON_UPDATE_COMMAND_UI(TID_SPLIT_LINE, OnUpdateSplitLine)
  121.         ON_COMMAND(TID_CENTER, OnCenter)
  122.         ON_UPDATE_COMMAND_UI(TID_CENTER, OnUpdateCenter)
  123.         ON_COMMAND(TID_DOUBLE_SPACE, OnDoubleSpace)
  124.         ON_UPDATE_COMMAND_UI(TID_DOUBLE_SPACE, OnUpdateDoubleSpace)
  125.         ON_COMMAND(TID_HANGING_INDENT, OnHangingIndent)
  126.         ON_UPDATE_COMMAND_UI(TID_HANGING_INDENT, OnUpdateHangingIndent)
  127.         ON_COMMAND(TID_PARA_BORDER, OnParaBorder)
  128.         ON_UPDATE_COMMAND_UI(TID_PARA_BORDER, OnUpdateParaBorder)
  129.         ON_COMMAND(TID_PARA_NORMAL, OnParaNormal)
  130.         ON_UPDATE_COMMAND_UI(TID_PARA_NORMAL, OnUpdateParaNormal)
  131.         ON_COMMAND(TID_RIGHT_INDENT, OnRightIndent)
  132.         ON_UPDATE_COMMAND_UI(TID_RIGHT_INDENT, OnUpdateRightIndent)
  133.         ON_COMMAND(TID_RIGHT_JUSTIFY, OnRightJustify)
  134.         ON_UPDATE_COMMAND_UI(TID_RIGHT_JUSTIFY, OnUpdateRightJustify)
  135.         ON_COMMAND(TID_JUSTIFY, OnJustify)
  136.         ON_UPDATE_COMMAND_UI(TID_JUSTIFY, OnUpdateJustify)
  137.         ON_COMMAND(TID_TAB_CLEAR, OnTabClear)
  138.         ON_UPDATE_COMMAND_UI(TID_TAB_CLEAR, OnUpdateTabClear)
  139.         ON_COMMAND(TID_TAB_CLEAR_ALL, OnTabClearAll)
  140.         ON_UPDATE_COMMAND_UI(TID_TAB_CLEAR_ALL, OnUpdateTabClearAll)
  141.         ON_COMMAND(TID_LEFT_INDENT, OnLeftIndent)
  142.         ON_UPDATE_COMMAND_UI(TID_LEFT_INDENT, OnUpdateLeftIndent)
  143.  
  144.         ON_COMMAND(TID_TABLE_INSERT, OnTableInsert)
  145.         ON_UPDATE_COMMAND_UI(TID_TABLE_INSERT, OnUpdateTableInsert)
  146.         ON_COMMAND(TID_TABLE_INSERT_ROW, OnTableInsertRow)
  147.         ON_UPDATE_COMMAND_UI(TID_TABLE_INSERT_ROW, OnUpdateTableInsertRow)
  148.         ON_COMMAND(TID_TABLE_SPLIT_CELL, OnTableSplitCell)
  149.         ON_UPDATE_COMMAND_UI(TID_TABLE_SPLIT_CELL, OnUpdateTableSplitCell)
  150.         ON_COMMAND(TID_TABLE_MERGE_CELLS, OnTableMergeCells)
  151.         ON_UPDATE_COMMAND_UI(TID_TABLE_MERGE_CELLS, OnUpdateTableMergeCells)
  152.         ON_COMMAND(TID_TABLE_DEL_CELLS, OnTableDelCells)
  153.         ON_UPDATE_COMMAND_UI(TID_TABLE_DEL_CELLS, OnUpdateTableDelCells)
  154.         ON_COMMAND(TID_TABLE_SHOW_GRID, OnTableShowGrid)
  155.         ON_UPDATE_COMMAND_UI(TID_TABLE_SHOW_GRID, OnUpdateTableShowGrid)
  156.         ON_COMMAND(TID_TABLE_ROW_POS, OnTableRowPos)
  157.         ON_UPDATE_COMMAND_UI(TID_TABLE_ROW_POS, OnUpdateTableRowPos)
  158.         ON_COMMAND(TID_TABLE_CELL_BORDER, OnTableCellBorder)
  159.         ON_UPDATE_COMMAND_UI(TID_TABLE_CELL_BORDER, OnUpdateTableCellBorder)
  160.         ON_COMMAND(TID_TABLE_CELL_SHADE, OnTableCellShade)
  161.         ON_UPDATE_COMMAND_UI(TID_TABLE_CELL_SHADE, OnUpdateTableCellShade)
  162.  
  163.         ON_COMMAND(TID_FILE_BEGIN, OnFileBegin)
  164.         ON_UPDATE_COMMAND_UI(TID_FILE_BEGIN, OnUpdateFileBegin)
  165.         ON_COMMAND(TID_FILE_END, OnFileEnd)
  166.         ON_UPDATE_COMMAND_UI(TID_FILE_END, OnUpdateFileEnd)
  167.         ON_COMMAND(TID_JUMP, OnJump)
  168.         ON_UPDATE_COMMAND_UI(TID_JUMP, OnUpdateJump)
  169.         ON_COMMAND(TID_LINE_BEGIN, OnLineBegin)
  170.         ON_UPDATE_COMMAND_UI(TID_LINE_BEGIN, OnUpdateLineBegin)
  171.         ON_COMMAND(TID_LINE_END, OnLineEnd)
  172.         ON_UPDATE_COMMAND_UI(TID_LINE_END, OnUpdateLineEnd)
  173.         ON_COMMAND(TID_NEXT_WORD, OnNextWord)
  174.         ON_UPDATE_COMMAND_UI(TID_NEXT_WORD, OnUpdateNextWord)
  175.         ON_COMMAND(TID_PREV_WORD, OnPrevWord)
  176.         ON_UPDATE_COMMAND_UI(TID_PREV_WORD, OnUpdatePrevWord)
  177.         ON_COMMAND(TID_PROTECTION_LOCK, OnProtectionLock)
  178.         ON_UPDATE_COMMAND_UI(TID_PROTECTION_LOCK, OnUpdateProtectionLock)
  179.         ON_COMMAND(TID_REPLACE, OnReplace)
  180.         ON_UPDATE_COMMAND_UI(TID_REPLACE, OnUpdateReplace)
  181.         ON_COMMAND(TID_SEARCH, OnSearch)
  182.         ON_UPDATE_COMMAND_UI(TID_SEARCH, OnUpdateSearch)
  183.         ON_COMMAND(TID_SEARCH_BACK, OnSearchBack)
  184.         ON_UPDATE_COMMAND_UI(TID_SEARCH_BACK, OnUpdateSearchBack)
  185.         ON_COMMAND(TID_SEARCH_FOR, OnSearchFor)
  186.         ON_UPDATE_COMMAND_UI(TID_SEARCH_FOR, OnUpdateSearchFor)
  187.         ON_COMMAND(TID_HELP, OnHelp)
  188.         ON_UPDATE_COMMAND_UI(TID_HELP, OnUpdateHelp)
  189.         //}}AFX_MSG_MAP
  190.  
  191.         // Message map defined outside of ClassWizard
  192.         ON_EN_CHANGE(AFX_IDW_PANE_FIRST,OnEditChange)
  193.  
  194.         // Uncomment the following message to overide the default
  195.         // implementation of toolbar and status bar
  196.         //ON_COMMAND(TID_STATUS_RIBBON, OnViewStatusBar)
  197.         //ON_UPDATE_COMMAND_UI(TID_STATUS_RIBBON, OnUpdateViewStatusBar)
  198.         //ON_COMMAND(TID_TOOL_BAR, OnViewToolbar)
  199.         //ON_UPDATE_COMMAND_UI(TID_TOOL_BAR, OnUpdateViewToolbar)
  200.  
  201. END_MESSAGE_MAP()
  202.  
  203. // CTerView construction/destruction
  204. CTerView::CTerView()
  205. {
  206.     // Variable initialization
  207.     m_hBuffer=0;
  208.     m_BufLen=0;
  209. }
  210.  
  211. CTerView::~CTerView()
  212. {
  213. }
  214.  
  215. // Specify the Window class: TerClass for window creation
  216. BOOL CTerView::PreCreateWindow(CREATESTRUCT& cs)
  217. {
  218.         LoadTerControl();
  219.  
  220.         ASSERT(cs.lpszClass == NULL);
  221.         cs.lpszClass = TER_CLASS;
  222.  
  223.         cs.style = cs.style | EditStyles();  // add edit styles
  224.  
  225.         return TRUE;
  226. }
  227.  
  228. // Specify address where mfc should store the address for the window process
  229. WNDPROC* CTerView::GetSuperWndProcAddr()
  230. {
  231.         static WNDPROC NEAR pfnSuper;
  232.         return &pfnSuper;
  233. }
  234.  
  235. // Call TER menu option
  236. void CTerView::TerMenu(WPARAM MenuOption)
  237. {
  238.     if (MenuEnable(MenuOption)) TerWindowProc(WM_COMMAND,MenuOption,0L);
  239. }
  240.  
  241. // Call TER window process
  242. LRESULT CTerView::TerWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  243. {
  244.     WNDPROC pfnWndProc = *GetSuperWndProcAddr();
  245.     #ifdef STRICT
  246.         return ::CallWindowProc(pfnWndProc, m_hWnd, nMsg, wParam, lParam);
  247.     #else
  248.         return ::CallWindowProc((FARPROC)pfnWndProc, m_hWnd, nMsg, wParam, lParam);
  249.     #endif
  250. }
  251.  
  252. // Return edit styles to be used with the window
  253. WORD CTerView::EditStyles()
  254. {
  255.     return TER_WORD_WRAP|TER_PAGE_MODE|TER_VSCROLL|TER_BORDER_MARGIN;  // control style
  256. }
  257.  
  258. /////////////////////////////////////////////////////////////////////////////
  259. // OnDraw: do nothing on draw
  260. void CTerView::OnDraw(CDC * /*pDC*/)
  261. {
  262. }
  263.  
  264. // printing preparation - used only for print preview
  265. BOOL CTerView::OnPreparePrinting(CPrintInfo * pInfo)
  266. {
  267.      struct StrTerField field;
  268.  
  269.      ::GetTerFields(m_hWnd,&field);
  270.  
  271.      pInfo->SetMinPage(0);                    // first page
  272.      pInfo->SetMaxPage(field.TotalPagesW-1);  // last page
  273.      pInfo->m_nCurPage=field.CurPageW;        // first page to print
  274.  
  275.      // default preparation
  276.      return DoPreparePrinting(pInfo);
  277. }
  278.  
  279. // printing -- used only for print preview
  280. void CTerView::OnPrint(CDC * pDC, CPrintInfo * pInfo)
  281. {
  282.    struct StrTerField field;
  283.  
  284.    ::TerPrintPreview(m_hWnd,pDC->m_hDC,pInfo->m_rectDraw,pInfo->m_nCurPage,FALSE);
  285.  
  286.    // update the last page
  287.    ::GetTerFields(m_hWnd,&field);
  288.    pInfo->SetMaxPage(field.TotalPagesW-1);  // last page
  289. }
  290.  
  291. // OnPaint: Call CWnd paint
  292. void CTerView::OnPaint()
  293. {
  294.         // do not call CView::OnPaint since it will call OnDraw
  295.         CWnd::OnPaint();
  296. }
  297.  
  298. /////////////////////////////////////////////////////////////////////////////
  299. // File io functions
  300. void CTerView::DeleteContents()
  301. {
  302.     HGLOBAL hMem;
  303.     LPSTR pMem;
  304.  
  305.     ASSERT_VALID(this);
  306.     ASSERT(m_hWnd!=NULL);
  307.  
  308.     // allocate an empty buffer
  309.     hMem=::GlobalAlloc(GMEM_MOVEABLE,1);
  310.     pMem=(LPSTR)::GlobalLock(hMem);
  311.     pMem[0]=0xD;                         // line delimiter
  312.     ::GlobalUnlock(hMem);
  313.     
  314.     ::SetTerBuffer(m_hWnd,hMem,1,NULL,TRUE);
  315.  
  316.     ASSERT_VALID(this);
  317. }
  318.  
  319. // Read and write CTerView object to archive, with a 4 byte length prefix.
  320. void CTerView::Serialize(CArchive& ar)
  321. {
  322.     ASSERT_VALID(this);
  323.     ASSERT(m_hWnd != NULL);
  324.  
  325.     if (ar.IsStoring()) {        // Save data
  326.         DWORD nLen = GetBuffer();
  327.         ar << nLen;              // write length
  328.         WriteArchive(ar);
  329.     }
  330.     else {                       // load data
  331.         DWORD dwLen;
  332.         ar >> dwLen;             // read length
  333.         ReadArchive(ar, dwLen);
  334.     }
  335.     ASSERT_VALID(this);
  336. }
  337.  
  338. // Read certain amount of text from the file, assume at least nLen
  339. // bytes are in the file.
  340. void CTerView::ReadArchive(CArchive& ar, DWORD nLen)
  341. {
  342.     ASSERT_VALID(this);
  343.     
  344.     HGLOBAL hBuf=::GlobalAlloc(GMEM_MOVEABLE, nLen+1);
  345.     char huge * pMem=(char huge *)GlobalLock(hBuf);
  346.  
  347.     if (pMem == NULL) {
  348.         AfxThrowMemoryException();
  349.         ASSERT(FALSE);
  350.     }
  351.     
  352.     // read the buffer
  353.     DWORD BlockSize=0x4000;       // 16 blocks
  354.     DWORD BytesDone=0;            // bytes written so far
  355.  
  356.     while (BytesDone<nLen) {
  357.        if ((BytesDone+BlockSize)>nLen) BlockSize=nLen-BytesDone;
  358.  
  359.        if (ar.Read(&(pMem[BytesDone]),(UINT)BlockSize)!=(UINT)BlockSize) {
  360.           ::GlobalUnlock(hBuf);
  361.           AfxThrowArchiveException(CArchiveException::endOfFile);
  362.           ASSERT(FALSE);
  363.        }
  364.        BytesDone+=BlockSize;
  365.     }
  366.     
  367.     // pass the handle to the control
  368.     pMem[nLen]=0;
  369.     ::GlobalUnlock(hBuf);
  370.     ::SetTerBuffer(m_hWnd,hBuf,nLen,(LPBYTE)"",TRUE);  // control now owns the handle
  371.  
  372.     ASSERT_VALID(this);
  373. }
  374.  
  375. // Write just the text to an archive, no length prefix.
  376. void CTerView::WriteArchive(CArchive& ar)
  377. {
  378.     ASSERT_VALID(this);
  379.     ASSERT(m_hBuffer!=NULL);
  380.  
  381.     char huge *pMem = (char huge *)::GlobalLock(m_hBuffer);
  382.  
  383.     ASSERT(pMem != NULL);
  384.  
  385.     // direct write for a huge buffer
  386.     TRY
  387.     {
  388.        DWORD BlockSize=0x4000;       // 16 blocks
  389.        DWORD BytesDone=0;            // bytes written so far
  390.  
  391.        while (BytesDone<m_BufLen) {
  392.           if ((BytesDone+BlockSize)>m_BufLen) BlockSize=m_BufLen-BytesDone;
  393.           ar.Write(&(pMem[BytesDone]),(UINT)BlockSize);
  394.           BytesDone+=BlockSize;
  395.        }
  396.     }
  397.     CATCH_ALL(e)
  398.     {
  399.         ::GlobalUnlock(m_hBuffer);
  400.         THROW_LAST();
  401.         ASSERT(FALSE);
  402.     }
  403.     END_CATCH_ALL
  404.     
  405.     // release our buffer
  406.     ::GlobalUnlock(m_hBuffer);
  407.     ::GlobalFree(m_hBuffer);
  408.     m_hBuffer=0;
  409.     m_BufLen=0;
  410.     
  411.     // mark the window as updated
  412.     ::TerSetModify(m_hWnd,FALSE);
  413.  
  414.     ASSERT_VALID(this);
  415. }
  416.  
  417. void CTerView::SerializeRaw(CArchive& ar)
  418.     // Read/Write object as stand-alone file.
  419. {
  420.     ASSERT_VALID(this);
  421.     if (ar.IsStoring())  {   // save data
  422.         GetBuffer();         // retrieve data from control
  423.         WriteArchive(ar);
  424.     }
  425.     else {                   // load file
  426.         CFile *pFile = ar.GetFile();
  427.         ASSERT(pFile->GetPosition() == 0);
  428.         DWORD nFileSize = pFile->GetLength();
  429.         ReadArchive(ar,nFileSize);
  430.     }
  431.     ASSERT_VALID(this);
  432. }
  433.  
  434. DWORD CTerView::GetBuffer()
  435.         // Retrieve the text buffer from the control
  436. {
  437.     if (m_hBuffer) ::GlobalFree(m_hBuffer);
  438.  
  439.     m_hBuffer=::GetTerBuffer(m_hWnd,(long far *)&m_BufLen);
  440.     return m_BufLen;
  441. }
  442.  
  443. /////////////////////////////////////////////////////////////////////////////
  444. // Command processing
  445.  
  446. void CTerView::OnEditChange()
  447. {
  448.     ASSERT_VALID(this);
  449.     GetDocument()->SetModifiedFlag();
  450.     ASSERT_VALID(this);
  451. }
  452.  
  453. // Called by MFC after creating the window
  454. int CTerView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  455. {
  456.     if (CView::OnCreate(lpCreateStruct) == -1) return -1;
  457.     
  458.     return 0;
  459. }
  460.  
  461. ///////////////////////////////////////////////////////////////////////////
  462. // Menu Commands
  463. // These functions simply invoke the given menu option
  464. //////////////////////////////////////////////////////////////////////////
  465. // Check if a menu item should be enabled
  466. BOOL CTerView::MenuEnable(int MenuItem)
  467. {
  468.     if (m_hWnd && MF_ENABLED==::TerMenuEnable(m_hWnd,MenuItem)) return TRUE;
  469.     else                                              return FALSE;
  470.  
  471. }
  472.  
  473. // Check if a menu item should be selected
  474. int CTerView::MenuSelect(int MenuItem)
  475. {
  476.     if (m_hWnd && MF_CHECKED==::TerMenuSelect(m_hWnd,MenuItem)) return 1;
  477.     else                                              return 0;
  478. }
  479.  
  480. // print
  481. void CTerView::OnFilePrint() {TerMenu(ID_PRINT);}
  482. void CTerView::OnUpdateFilePrint(CCmdUI* pCmdUI)
  483. {
  484.     pCmdUI->Enable(MenuEnable(ID_PRINT));
  485.     pCmdUI->SetCheck(MenuSelect(ID_PRINT));
  486. }
  487.  
  488. // print preview
  489. void CTerView::OnFilePrintPreview() {TerMenu(ID_PRINT_PREVIEW);}
  490. void CTerView::OnUpdateFilePrintPreview(CCmdUI* pCmdUI)
  491. {
  492.     pCmdUI->Enable(MenuEnable(ID_PRINT_PREVIEW));
  493.     pCmdUI->SetCheck(MenuSelect(ID_PRINT_PREVIEW));
  494. }
  495.  
  496. // clipboard - cut
  497. void CTerView::OnEditCut() {TerMenu(ID_CUT);}
  498. void CTerView::OnUpdateEditCut(CCmdUI* pCmdUI)
  499. {
  500.     pCmdUI->Enable(MenuEnable(ID_CUT));
  501.     pCmdUI->SetCheck(MenuSelect(ID_CUT));
  502. }
  503.  
  504. // clipboard - copy
  505. void CTerView::OnEditCopy() {TerMenu(ID_COPY);}
  506. void CTerView::OnUpdateEditCopy(CCmdUI* pCmdUI)
  507. {
  508.     pCmdUI->Enable(MenuEnable(ID_COPY));
  509.     pCmdUI->SetCheck(MenuSelect(ID_COPY));
  510. }
  511.  
  512. // clipboard - paste
  513. void CTerView::OnEditPaste() {TerMenu(ID_PASTE);}
  514. void CTerView::OnUpdateEditPaste(CCmdUI* pCmdUI)
  515. {
  516.     pCmdUI->Enable(MenuEnable(ID_PASTE));
  517.     pCmdUI->SetCheck(MenuSelect(ID_PASTE));
  518. }
  519.  
  520. // undo
  521. void CTerView::OnEditUndo(){TerMenu(ID_UNDO);}
  522. void CTerView::OnUpdateEditUndo(CCmdUI* pCmdUI)
  523. {
  524.     pCmdUI->Enable(MenuEnable(ID_UNDO));
  525.     pCmdUI->SetCheck(MenuSelect(ID_UNDO));
  526. }
  527.  
  528. // Other edit commands
  529. void CTerView::OnBlockCopy(){TerMenu(ID_BLOCK_COPY);}
  530. void CTerView::OnUpdateBlockCopy(CCmdUI* pCmdUI)
  531. {
  532.     pCmdUI->Enable(MenuEnable(ID_BLOCK_COPY));
  533.     pCmdUI->SetCheck(MenuSelect(ID_BLOCK_COPY));
  534. }
  535.  
  536. void CTerView::OnBlockMove(){TerMenu(ID_BLOCK_MOVE);}
  537. void CTerView::OnUpdateBlockMove(CCmdUI* pCmdUI)
  538. {
  539.     pCmdUI->Enable(MenuEnable(ID_BLOCK_MOVE));
  540.     pCmdUI->SetCheck(MenuSelect(ID_BLOCK_MOVE));
  541. }
  542.  
  543. void CTerView::OnDelLine() {TerMenu(ID_DEL_LINE);}
  544. void CTerView::OnUpdateDelLine(CCmdUI* pCmdUI)
  545. {
  546.     pCmdUI->Enable(MenuEnable(ID_DEL_LINE));
  547.     pCmdUI->SetCheck(MenuSelect(ID_DEL_LINE));
  548. }
  549.  
  550. void CTerView::OnEditPict() {TerMenu(ID_EDIT_PICT);}
  551. void CTerView::OnUpdateEditPict(CCmdUI* pCmdUI)
  552. {
  553.     pCmdUI->Enable(MenuEnable(ID_EDIT_PICT));
  554.     pCmdUI->SetCheck(MenuSelect(ID_EDIT_PICT));
  555. }
  556.  
  557. void CTerView::OnEditHdrFtr() {TerMenu(ID_EDIT_HDR_FTR);}
  558. void CTerView::OnUpdateEditHdrFtr(CCmdUI* pCmdUI)
  559. {
  560.     pCmdUI->Enable(MenuEnable(ID_EDIT_HDR_FTR));
  561.     pCmdUI->SetCheck(MenuSelect(ID_EDIT_HDR_FTR));
  562. }
  563.  
  564. void CTerView::OnInsAft() {TerMenu(ID_INS_AFT);}
  565. void CTerView::OnUpdateInsAft(CCmdUI* pCmdUI)
  566. {
  567.     pCmdUI->Enable(MenuEnable(ID_INS_AFT));
  568.     pCmdUI->SetCheck(MenuSelect(ID_INS_AFT));
  569. }
  570.  
  571. void CTerView::OnInsBef() {TerMenu(ID_INS_BEF);}
  572. void CTerView::OnUpdateInsBef(CCmdUI* pCmdUI)
  573. {
  574.     pCmdUI->Enable(MenuEnable(ID_INS_BEF));
  575.     pCmdUI->SetCheck(MenuSelect(ID_INS_BEF));
  576. }
  577.  
  578. void CTerView::OnJoinLine() {TerMenu(ID_JOIN_LINE);}
  579. void CTerView::OnUpdateJoinLine(CCmdUI* pCmdUI)
  580. {
  581.     pCmdUI->Enable(MenuEnable(ID_JOIN_LINE));
  582.     pCmdUI->SetCheck(MenuSelect(ID_JOIN_LINE));
  583. }
  584.  
  585. void CTerView::OnPasteSpec() {TerMenu(ID_PASTE_SPEC);}
  586. void CTerView::OnUpdatePasteSpec(CCmdUI* pCmdUI)
  587. {
  588.     pCmdUI->Enable(MenuEnable(ID_PASTE_SPEC));
  589.     pCmdUI->SetCheck(MenuSelect(ID_PASTE_SPEC));
  590. }                                  
  591.  
  592. void CTerView::OnRepaginate() {TerMenu(ID_REPAGINATE);}
  593. void CTerView::OnUpdateRepaginate(CCmdUI* pCmdUI)
  594. {
  595.     pCmdUI->Enable(MenuEnable(ID_REPAGINATE));
  596.     pCmdUI->SetCheck(MenuSelect(ID_REPAGINATE));
  597. }
  598.  
  599. void CTerView::OnSectOptions() {TerMenu(ID_SECT_OPTIONS);}
  600. void CTerView::OnUpdateSectOptions(CCmdUI* pCmdUI)
  601. {
  602.     pCmdUI->Enable(MenuEnable(ID_SECT_OPTIONS));
  603.     pCmdUI->SetCheck(MenuSelect(ID_SECT_OPTIONS));
  604. }
  605.  
  606. void CTerView::OnSelectAll() {TerMenu(ID_SELECT_ALL);}
  607. void CTerView::OnUpdateSelectAll(CCmdUI* pCmdUI)
  608. {
  609.     pCmdUI->Enable(MenuEnable(ID_SELECT_ALL));
  610.     pCmdUI->SetCheck(MenuSelect(ID_SELECT_ALL));
  611. }
  612.  
  613. void CTerView::OnSplitLine() {TerMenu(ID_SPLIT_LINE);}
  614. void CTerView::OnUpdateSplitLine(CCmdUI* pCmdUI)
  615. {
  616.     pCmdUI->Enable(MenuEnable(ID_SPLIT_LINE));
  617.     pCmdUI->SetCheck(MenuSelect(ID_SPLIT_LINE));
  618. }
  619.  
  620. // View menu options
  621. void CTerView::OnViewHiddentext() {TerMenu(ID_SHOW_HIDDEN);}
  622. void CTerView::OnUpdateViewHiddentext(CCmdUI* pCmdUI)
  623. {
  624.     pCmdUI->Enable(MenuEnable(ID_SHOW_HIDDEN));
  625.     pCmdUI->SetCheck(MenuSelect(ID_SHOW_HIDDEN));
  626. }
  627.  
  628. void CTerView::OnViewPagemode() {TerMenu(ID_PAGE_MODE);}
  629. void CTerView::OnUpdateViewPagemode(CCmdUI* pCmdUI)
  630. {
  631.     pCmdUI->Enable(MenuEnable(ID_PAGE_MODE));
  632.     pCmdUI->SetCheck(MenuSelect(ID_PAGE_MODE));
  633. }
  634.  
  635. void CTerView::OnViewParagraphmarker() {TerMenu(ID_SHOW_PARA_MARK);}
  636. void CTerView::OnUpdateViewParagraphmarker(CCmdUI* pCmdUI)
  637. {
  638.     pCmdUI->Enable(MenuEnable(ID_SHOW_PARA_MARK));
  639.     pCmdUI->SetCheck(MenuSelect(ID_SHOW_PARA_MARK));
  640. }
  641.  
  642. void CTerView::OnViewRuler() {TerMenu(ID_RULER);}
  643. void CTerView::OnUpdateViewRuler(CCmdUI* pCmdUI)
  644. {
  645.     pCmdUI->Enable(MenuEnable(ID_RULER));
  646.     pCmdUI->SetCheck(MenuSelect(ID_RULER));
  647. }
  648.  
  649. void CTerView::OnViewHyperlinkCursor() {TerMenu(ID_SHOW_HYPERLINK_CURSOR);}
  650. void CTerView::OnUpdateViewHyperlinkCursor(CCmdUI* pCmdUI)
  651. {
  652.     pCmdUI->Enable(MenuEnable(ID_SHOW_HYPERLINK_CURSOR));
  653.     pCmdUI->SetCheck(MenuSelect(ID_SHOW_HYPERLINK_CURSOR));
  654. }
  655.  
  656. void CTerView::OnViewStatusBar() {TerMenu(ID_STATUS_RIBBON);}
  657. void CTerView::OnUpdateViewStatusBar(CCmdUI* pCmdUI)
  658. {
  659.     pCmdUI->Enable(MenuEnable(ID_STATUS_RIBBON));
  660.     pCmdUI->SetCheck(MenuSelect(ID_STATUS_RIBBON));
  661. }
  662.  
  663. void CTerView::OnViewToolbar() {TerMenu(ID_TOOL_BAR);}
  664. void CTerView::OnUpdateViewToolbar(CCmdUI* pCmdUI)
  665. {
  666.     pCmdUI->Enable(MenuEnable(ID_TOOL_BAR));
  667.     pCmdUI->SetCheck(MenuSelect(ID_TOOL_BAR));
  668. }
  669.  
  670. void CTerView::OnViewHdrFtr() {TerMenu(ID_VIEW_HDR_FTR);}
  671. void CTerView::OnUpdateViewHdrFtr(CCmdUI* pCmdUI)
  672. {
  673.     pCmdUI->Enable(MenuEnable(ID_VIEW_HDR_FTR));
  674.     pCmdUI->SetCheck(MenuSelect(ID_VIEW_HDR_FTR));
  675. }
  676.  
  677. // Insert menu options
  678. void CTerView::OnInsertColumnbreak() {TerMenu(ID_COL_BREAK);}
  679. void CTerView::OnUpdateInsertColumnbreak(CCmdUI* pCmdUI)
  680. {
  681.     pCmdUI->Enable(MenuEnable(ID_COL_BREAK));
  682.     pCmdUI->SetCheck(MenuSelect(ID_COL_BREAK));
  683. }
  684.  
  685. void CTerView::OnInsertPagebreak() {TerMenu(ID_PAGE_BREAK);}
  686. void CTerView::OnUpdateInsertPagebreak(CCmdUI* pCmdUI)
  687. {
  688.     pCmdUI->Enable(MenuEnable(ID_PAGE_BREAK));
  689.     pCmdUI->SetCheck(MenuSelect(ID_PAGE_BREAK));
  690. }
  691.  
  692. void CTerView::OnInsertSectionbreak() {TerMenu(ID_SECT_BREAK);}
  693. void CTerView::OnUpdateInsertSectionbreak(CCmdUI* pCmdUI)
  694. {
  695.     pCmdUI->Enable(MenuEnable(ID_SECT_BREAK));
  696.     pCmdUI->SetCheck(MenuSelect(ID_SECT_BREAK));
  697. }
  698.  
  699. void CTerView::OnInsertObject() {TerMenu(ID_INSERT_OBJECT);}
  700. void CTerView::OnUpdateInsertObject(CCmdUI* pCmdUI)
  701. {
  702.     pCmdUI->Enable(MenuEnable(ID_INSERT_OBJECT));
  703.     pCmdUI->SetCheck(MenuSelect(ID_INSERT_OBJECT));
  704. }
  705.  
  706. void CTerView::OnInsertPicture() {TerMenu(ID_PICT_FROM_FILE);}
  707. void CTerView::OnUpdateInsertPicture(CCmdUI* pCmdUI)
  708. {
  709.     pCmdUI->Enable(MenuEnable(ID_PICT_FROM_FILE));
  710.     pCmdUI->SetCheck(MenuSelect(ID_PICT_FROM_FILE));
  711. }
  712.  
  713. // Font and character style functions
  714. void CTerView::OnFontBold() {TerMenu(ID_BOLD_ON);}
  715. void CTerView::OnUpdateFontBold(CCmdUI* pCmdUI)
  716. {
  717.     pCmdUI->Enable(MenuEnable(ID_BOLD_ON));
  718.     pCmdUI->SetCheck(MenuSelect(ID_BOLD_ON));
  719. }
  720.  
  721. void CTerView::OnFontDoubleunderline() {TerMenu(ID_ULINED_ON);}
  722. void CTerView::OnUpdateFontDoubleunderline(CCmdUI* pCmdUI)
  723. {
  724.     pCmdUI->Enable(MenuEnable(ID_ULINED_ON));
  725.     pCmdUI->SetCheck(MenuSelect(ID_ULINED_ON));
  726. }
  727.  
  728. void CTerView::OnFontFonts() {TerMenu(ID_FONTS);}
  729. void CTerView::OnUpdateFontFonts(CCmdUI* pCmdUI)
  730. {
  731.     pCmdUI->Enable(MenuEnable(ID_FONTS));
  732.     pCmdUI->SetCheck(MenuSelect(ID_FONTS));
  733. }
  734.  
  735. void CTerView::OnFontHidden() {TerMenu(ID_HIDDEN_ON);}
  736. void CTerView::OnUpdateFontHidden(CCmdUI* pCmdUI)
  737. {
  738.     pCmdUI->Enable(MenuEnable(ID_HIDDEN_ON));
  739.     pCmdUI->SetCheck(MenuSelect(ID_HIDDEN_ON));
  740. }
  741.  
  742. void CTerView::OnFontItalic() {TerMenu(ID_ITALIC_ON);}
  743. void CTerView::OnUpdateFontItalic(CCmdUI* pCmdUI)
  744. {
  745.     pCmdUI->Enable(MenuEnable(ID_ITALIC_ON));
  746.     pCmdUI->SetCheck(MenuSelect(ID_ITALIC_ON));
  747. }
  748.  
  749. void CTerView::OnFontNormal() {TerMenu(ID_CHAR_NORMAL);}
  750. void CTerView::OnUpdateFontNormal(CCmdUI* pCmdUI)
  751. {
  752.     pCmdUI->Enable(MenuEnable(ID_CHAR_NORMAL));
  753.     pCmdUI->SetCheck(MenuSelect(ID_CHAR_NORMAL));
  754. }
  755.  
  756. void CTerView::OnFontProtect() {TerMenu(ID_PROTECT_ON);}
  757. void CTerView::OnUpdateFontProtect(CCmdUI* pCmdUI)
  758. {
  759.     pCmdUI->Enable(MenuEnable(ID_PROTECT_ON));
  760.     pCmdUI->SetCheck(MenuSelect(ID_PROTECT_ON));
  761. }
  762.  
  763. void CTerView::OnFontStrikethrough() {TerMenu(ID_STRIKE_ON);}
  764. void CTerView::OnUpdateFontStrikethrough(CCmdUI* pCmdUI)
  765. {
  766.     pCmdUI->Enable(MenuEnable(ID_STRIKE_ON));
  767.     pCmdUI->SetCheck(MenuSelect(ID_STRIKE_ON));
  768. }
  769.  
  770. void CTerView::OnFontSubscript() {TerMenu(ID_SUBSCR_ON);}
  771. void CTerView::OnUpdateFontSubscript(CCmdUI* pCmdUI)
  772. {
  773.     pCmdUI->Enable(MenuEnable(ID_SUBSCR_ON));
  774.     pCmdUI->SetCheck(MenuSelect(ID_SUBSCR_ON));
  775. }
  776.  
  777. void CTerView::OnFontSuperscript() {TerMenu(ID_SUPSCR_ON);}
  778. void CTerView::OnUpdateFontSuperscript(CCmdUI* pCmdUI)
  779. {
  780.     pCmdUI->Enable(MenuEnable(ID_SUPSCR_ON));
  781.     pCmdUI->SetCheck(MenuSelect(ID_SUPSCR_ON));
  782. }
  783.  
  784. void CTerView::OnFontUnderline() {TerMenu(ID_ULINE_ON);}
  785. void CTerView::OnUpdateFontUnderline(CCmdUI* pCmdUI)
  786. {
  787.     pCmdUI->Enable(MenuEnable(ID_ULINE_ON));
  788.     pCmdUI->SetCheck(MenuSelect(ID_ULINE_ON));
  789. }
  790.  
  791. void CTerView::OnFontColor() {TerMenu(ID_COLOR);}
  792. void CTerView::OnUpdateFontColor(CCmdUI* pCmdUI)
  793. {
  794.     pCmdUI->Enable(MenuEnable(ID_COLOR));
  795.     pCmdUI->SetCheck(MenuSelect(ID_COLOR));
  796. }
  797.  
  798. void CTerView::OnFontBkColor() {TerMenu(ID_BK_COLOR);}
  799. void CTerView::OnUpdateFontBkColor(CCmdUI* pCmdUI)
  800. {
  801.     pCmdUI->Enable(MenuEnable(ID_BK_COLOR));
  802.     pCmdUI->SetCheck(MenuSelect(ID_BK_COLOR));
  803. }
  804.  
  805. // Paragraph options
  806. void CTerView::OnCenter() {TerMenu(ID_CENTER);}
  807. void CTerView::OnUpdateCenter(CCmdUI* pCmdUI)
  808. {
  809.     pCmdUI->Enable(MenuEnable(ID_CENTER));
  810.     pCmdUI->SetCheck(MenuSelect(ID_CENTER));
  811. }
  812.  
  813. void CTerView::OnDoubleSpace() {TerMenu(ID_DOUBLE_SPACE);}
  814. void CTerView::OnUpdateDoubleSpace(CCmdUI* pCmdUI)
  815. {
  816.     pCmdUI->Enable(MenuEnable(ID_DOUBLE_SPACE));
  817.     pCmdUI->SetCheck(MenuSelect(ID_DOUBLE_SPACE));
  818. }
  819.  
  820. void CTerView::OnHangingIndent() {TerMenu(ID_HANGING_INDENT);}
  821. void CTerView::OnUpdateHangingIndent(CCmdUI* pCmdUI)
  822. {
  823.     pCmdUI->Enable(MenuEnable(ID_HANGING_INDENT));
  824.     pCmdUI->SetCheck(MenuSelect(ID_HANGING_INDENT));
  825. }
  826.  
  827. void CTerView::OnParaBorder() {TerMenu(ID_PARA_BORDER);}
  828. void CTerView::OnUpdateParaBorder(CCmdUI* pCmdUI)
  829. {
  830.     pCmdUI->Enable(MenuEnable(ID_PARA_BORDER));
  831.     pCmdUI->SetCheck(MenuSelect(ID_PARA_BORDER));
  832. }
  833.  
  834. void CTerView::OnParaNormal() {TerMenu(ID_PARA_NORMAL);}
  835. void CTerView::OnUpdateParaNormal(CCmdUI* pCmdUI)
  836. {
  837.     pCmdUI->Enable(MenuEnable(ID_PARA_NORMAL));
  838.     pCmdUI->SetCheck(MenuSelect(ID_PARA_NORMAL));
  839. }
  840.  
  841. void CTerView::OnRightIndent() {TerMenu(ID_RIGHT_INDENT);}
  842. void CTerView::OnUpdateRightIndent(CCmdUI* pCmdUI)
  843. {
  844.     pCmdUI->Enable(MenuEnable(ID_RIGHT_INDENT));
  845.     pCmdUI->SetCheck(MenuSelect(ID_RIGHT_INDENT));
  846. }
  847.  
  848. void CTerView::OnRightJustify() {TerMenu(ID_RIGHT_JUSTIFY);}
  849. void CTerView::OnUpdateRightJustify(CCmdUI* pCmdUI)
  850. {
  851.     pCmdUI->Enable(MenuEnable(ID_RIGHT_JUSTIFY));
  852.     pCmdUI->SetCheck(MenuSelect(ID_RIGHT_JUSTIFY));
  853. }
  854.  
  855. void CTerView::OnJustify() {TerMenu(ID_JUSTIFY);}
  856. void CTerView::OnUpdateJustify(CCmdUI* pCmdUI)
  857. {
  858.     pCmdUI->Enable(MenuEnable(ID_JUSTIFY));
  859.     pCmdUI->SetCheck(MenuSelect(ID_JUSTIFY));
  860. }
  861.  
  862. void CTerView::OnTabClear() {TerMenu(ID_TAB_CLEAR);}
  863. void CTerView::OnUpdateTabClear(CCmdUI* pCmdUI)
  864. {
  865.     pCmdUI->Enable(MenuEnable(ID_TAB_CLEAR));
  866.     pCmdUI->SetCheck(MenuSelect(ID_TAB_CLEAR));
  867. }
  868.  
  869. void CTerView::OnTabClearAll() {TerMenu(ID_TAB_CLEAR_ALL);}
  870. void CTerView::OnUpdateTabClearAll(CCmdUI* pCmdUI)
  871. {
  872.     pCmdUI->Enable(MenuEnable(ID_TAB_CLEAR_ALL));
  873.     pCmdUI->SetCheck(MenuSelect(ID_TAB_CLEAR_ALL));
  874. }
  875.  
  876. void CTerView::OnLeftIndent() {TerMenu(ID_LEFT_INDENT);}
  877. void CTerView::OnUpdateLeftIndent(CCmdUI* pCmdUI)
  878. {
  879.     pCmdUI->Enable(MenuEnable(ID_LEFT_INDENT));
  880.     pCmdUI->SetCheck(MenuSelect(ID_LEFT_INDENT));
  881. }
  882.  
  883. // table optoins
  884. void CTerView::OnTableInsert() {TerMenu(ID_TABLE_INSERT);}
  885. void CTerView::OnUpdateTableInsert(CCmdUI* pCmdUI)
  886. {
  887.     pCmdUI->Enable(MenuEnable(ID_TABLE_INSERT));
  888.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_INSERT));
  889. }
  890.  
  891. void CTerView::OnTableInsertRow() {TerMenu(ID_TABLE_INSERT_ROW);}
  892. void CTerView::OnUpdateTableInsertRow(CCmdUI* pCmdUI)
  893. {
  894.     pCmdUI->Enable(MenuEnable(ID_TABLE_INSERT_ROW));
  895.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_INSERT_ROW));
  896. }
  897.  
  898. void CTerView::OnTableSplitCell() {TerMenu(ID_TABLE_SPLIT_CELL);}
  899. void CTerView::OnUpdateTableSplitCell(CCmdUI* pCmdUI)
  900. {
  901.     pCmdUI->Enable(MenuEnable(ID_TABLE_SPLIT_CELL));
  902.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_SPLIT_CELL));
  903. }
  904.  
  905. void CTerView::OnTableMergeCells() {TerMenu(ID_TABLE_MERGE_CELLS);}
  906. void CTerView::OnUpdateTableMergeCells(CCmdUI* pCmdUI)
  907. {
  908.     pCmdUI->Enable(MenuEnable(ID_TABLE_MERGE_CELLS));
  909.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_MERGE_CELLS));
  910. }
  911.  
  912. void CTerView::OnTableDelCells() {TerMenu(ID_TABLE_DEL_CELLS);}
  913. void CTerView::OnUpdateTableDelCells(CCmdUI* pCmdUI)
  914. {
  915.     pCmdUI->Enable(MenuEnable(ID_TABLE_DEL_CELLS));
  916.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_DEL_CELLS));
  917. }
  918.  
  919. void CTerView::OnTableShowGrid() {TerMenu(ID_TABLE_SHOW_GRID);}
  920. void CTerView::OnUpdateTableShowGrid(CCmdUI* pCmdUI)
  921. {
  922.     pCmdUI->Enable(MenuEnable(ID_TABLE_SHOW_GRID));
  923.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_SHOW_GRID));
  924. }
  925.  
  926. void CTerView::OnTableRowPos() {TerMenu(ID_TABLE_ROW_POS);}
  927. void CTerView::OnUpdateTableRowPos(CCmdUI* pCmdUI)
  928. {
  929.     pCmdUI->Enable(MenuEnable(ID_TABLE_ROW_POS));
  930.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_ROW_POS));
  931. }
  932.  
  933. void CTerView::OnTableCellBorder() {TerMenu(ID_TABLE_CELL_BORDER);}
  934. void CTerView::OnUpdateTableCellBorder(CCmdUI* pCmdUI)
  935. {
  936.     pCmdUI->Enable(MenuEnable(ID_TABLE_CELL_BORDER));
  937.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_CELL_BORDER));
  938. }
  939.  
  940. void CTerView::OnTableCellShade() {TerMenu(ID_TABLE_CELL_SHADE);}
  941. void CTerView::OnUpdateTableCellShade(CCmdUI* pCmdUI)
  942. {
  943.     pCmdUI->Enable(MenuEnable(ID_TABLE_CELL_SHADE));
  944.     pCmdUI->SetCheck(MenuSelect(ID_TABLE_CELL_SHADE));
  945. }
  946.  
  947. // Other menu options
  948. void CTerView::OnFileBegin() {TerMenu(ID_FILE_BEGIN);}
  949. void CTerView::OnUpdateFileBegin(CCmdUI* pCmdUI)
  950. {
  951.     pCmdUI->Enable(MenuEnable(ID_FILE_BEGIN));
  952.     pCmdUI->SetCheck(MenuSelect(ID_FILE_BEGIN));
  953. }
  954.  
  955. void CTerView::OnFileEnd() {TerMenu(ID_FILE_END);}
  956. void CTerView::OnUpdateFileEnd(CCmdUI* pCmdUI)
  957. {
  958.     pCmdUI->Enable(MenuEnable(ID_FILE_END));
  959.     pCmdUI->SetCheck(MenuSelect(ID_FILE_END));
  960. }
  961.  
  962. void CTerView::OnJump() {TerMenu(ID_JUMP);}
  963. void CTerView::OnUpdateJump(CCmdUI* pCmdUI)
  964. {
  965.     pCmdUI->Enable(MenuEnable(ID_JUMP));
  966.     pCmdUI->SetCheck(MenuSelect(ID_JUMP));
  967. }
  968.  
  969. void CTerView::OnLineBegin() {TerMenu(ID_LINE_BEGIN);}
  970. void CTerView::OnUpdateLineBegin(CCmdUI* pCmdUI)
  971. {
  972.     pCmdUI->Enable(MenuEnable(ID_LINE_BEGIN));
  973.     pCmdUI->SetCheck(MenuSelect(ID_LINE_BEGIN));
  974. }
  975.  
  976. void CTerView::OnLineEnd() {TerMenu(ID_LINE_END);}
  977. void CTerView::OnUpdateLineEnd(CCmdUI* pCmdUI)
  978. {
  979.     pCmdUI->Enable(MenuEnable(ID_LINE_END));
  980.     pCmdUI->SetCheck(MenuSelect(ID_LINE_END));
  981. }
  982.  
  983. void CTerView::OnNextWord() {TerMenu(ID_NEXT_WORD);}
  984. void CTerView::OnUpdateNextWord(CCmdUI* pCmdUI)
  985. {
  986.     pCmdUI->Enable(MenuEnable(ID_NEXT_WORD));
  987.     pCmdUI->SetCheck(MenuSelect(ID_NEXT_WORD));
  988. }
  989.  
  990. void CTerView::OnPrevWord() {TerMenu(ID_PREV_WORD);}
  991. void CTerView::OnUpdatePrevWord(CCmdUI* pCmdUI)
  992. {
  993.     pCmdUI->Enable(MenuEnable(ID_PREV_WORD));
  994.     pCmdUI->SetCheck(MenuSelect(ID_PREV_WORD));
  995. }
  996.  
  997. void CTerView::OnProtectionLock() {TerMenu(ID_PROTECTION_LOCK);}
  998. void CTerView::OnUpdateProtectionLock(CCmdUI* pCmdUI)
  999. {                                  
  1000.     pCmdUI->Enable(MenuEnable(ID_PROTECTION_LOCK));
  1001.     pCmdUI->SetCheck(MenuSelect(ID_PROTECTION_LOCK));
  1002. }
  1003.  
  1004. void CTerView::OnReplace() {TerMenu(ID_REPLACE);}
  1005. void CTerView::OnUpdateReplace(CCmdUI* pCmdUI)
  1006. {
  1007.     pCmdUI->Enable(MenuEnable(ID_REPLACE));
  1008.     pCmdUI->SetCheck(MenuSelect(ID_REPLACE));
  1009. }
  1010.  
  1011. void CTerView::OnSearch() {TerMenu(ID_SEARCH);}
  1012. void CTerView::OnUpdateSearch(CCmdUI* pCmdUI)
  1013. {
  1014.     pCmdUI->Enable(MenuEnable(ID_SEARCH));
  1015.     pCmdUI->SetCheck(MenuSelect(ID_SEARCH));
  1016. }
  1017.  
  1018. void CTerView::OnSearchBack() {TerMenu(ID_SEARCH_BACK);}
  1019. void CTerView::OnUpdateSearchBack(CCmdUI* pCmdUI)
  1020. {
  1021.     pCmdUI->Enable(MenuEnable(ID_SEARCH_BACK));
  1022.     pCmdUI->SetCheck(MenuSelect(ID_SEARCH_BACK));
  1023. }
  1024.  
  1025. void CTerView::OnSearchFor() {TerMenu(ID_SEARCH_FOR);}
  1026. void CTerView::OnUpdateSearchFor(CCmdUI* pCmdUI)
  1027. {
  1028.     pCmdUI->Enable(MenuEnable(ID_SEARCH_FOR));
  1029.     pCmdUI->SetCheck(MenuSelect(ID_SEARCH_FOR));
  1030. }
  1031.  
  1032. void CTerView::OnHelp() {TerMenu(ID_TER_HELP);}
  1033. void CTerView::OnUpdateHelp(CCmdUI* pCmdUI)
  1034. {
  1035.     pCmdUI->Enable(MenuEnable(ID_TER_HELP));
  1036.     pCmdUI->SetCheck(MenuSelect(ID_TER_HELP));
  1037. }
  1038.