home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / MSGTRACE.ZIP / MyProjects / MsgTrace / MsgTracer / OutputView.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-30  |  30.2 KB  |  1,214 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. // File        : OutputView.cpp
  4. // Project     : MsgTrace
  5. // Component   : MsgTracer
  6. //---------------------------------------------------------------------------
  7. // Description : output-view class
  8. //
  9. /////////////////////////////////////////////////////////////////////////////
  10. //
  11. // SourceSafe Strings. Do not change.
  12. //---------------------------------------------------------------------------
  13. // $Author: jeskes $
  14. // $Date: $
  15. // $Revision: $
  16. //
  17. /////////////////////////////////////////////////////////////////////////////
  18.  
  19. #include "stdafx.h"
  20.  
  21. #include "MsgTracerApp.h"
  22. #include "mainfrm.h"
  23.  
  24. #include "OutputDoc.h"
  25. #include "OutputLine.h"
  26. #include "OutputView.h"
  27.  
  28. #include "ColFont.h"
  29.  
  30. /////////////////////////////////////////////////////////////////////////////
  31.  
  32. #ifdef _DEBUG
  33. #undef THIS_FILE
  34. static char BASED_CODE THIS_FILE[] = __FILE__;
  35. #endif
  36.  
  37. /////////////////////////////////////////////////////////////////////////////
  38.  
  39. #define ENDOFLINE                                    ((int) 0x7fff )
  40. #define ENDOFLINES                                    ((int) 0x7fff )
  41. #define CURRENT_VALUE                                ((int) 0xffff )
  42.  
  43. #define SCROLL_RIGHT                                0x0001
  44. #define SCROLL_LEFT                                    0x0002
  45. #define SCROLL_UP                                    0x0010
  46. #define SCROLL_DOWN                                    0x0020
  47. #define SCROLL_POSITION                                0x0100
  48.  
  49. #define CARET_WIDTH                                    2
  50. #define CARET_HEIGHT                                m_nRowHeight
  51.  
  52. #define CAPTURE_TIMER                                100
  53. #define CAPTURE_TIMER_TIMEOUT                        50
  54.  
  55. /////////////////////////////////////////////////////////////////////////////
  56. // COutputView
  57. /////////////////////////////////////////////////////////////////////////////
  58.  
  59. IMPLEMENT_DYNCREATE(COutputView, CScrollView)
  60.  
  61. BEGIN_MESSAGE_MAP(COutputView, CScrollView)
  62.     //{{AFX_MSG_MAP(COutputView)
  63.     ON_WM_SIZE()
  64.     ON_WM_CREATE()
  65.     ON_WM_SETFOCUS()
  66.     ON_COMMAND(ID_VIEW_FONT, OnViewFont)
  67.     ON_WM_KILLFOCUS()
  68.     ON_WM_SETCURSOR()
  69.     ON_WM_LBUTTONDOWN()
  70.     ON_WM_RBUTTONUP()
  71.     ON_WM_KEYDOWN()
  72.     ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  73.     ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
  74.     ON_WM_LBUTTONUP()
  75.     ON_WM_TIMER()
  76.     ON_WM_MOUSEMOVE()
  77.     //}}AFX_MSG_MAP
  78.  
  79.     // Standard Print commands (print only - not preview)
  80.     ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
  81. END_MESSAGE_MAP()
  82.  
  83. /////////////////////////////////////////////////////////////////////////////
  84. // COutputView: construction
  85. /////////////////////////////////////////////////////////////////////////////
  86.  
  87. COutputView::COutputView() :
  88.  
  89.     m_hPrinterFont( NULL ),
  90.     
  91.     m_nPrintRowHeight( 0 ),
  92.     m_nPrintLinesPerPage( 0 ),
  93.  
  94.     m_nMaxVisibleLines( 0 ),
  95.     m_nRowWidth( 0 ),
  96.     m_nRowHeight( 0 ),
  97.  
  98.     m_nCurCol( 0 ),
  99.     m_nCurRow( 0 ),
  100.     m_nSelCol( 0 ),
  101.     m_nSelRow( 0 ),
  102.  
  103.     m_bWhileSelecting( FALSE ),
  104.  
  105.     m_nIDCaptureTimer( 0 )
  106.  
  107. {
  108.     m_pColoredFont = new CColoredFont( "out" );
  109.     m_pTrackMenu = new CMenu;
  110.  
  111.     m_pTrackMenu->LoadMenu( IDR_PROPS_OUTPUTTYPE );
  112. }
  113.  
  114. /////////////////////////////////////////////////////////////////////////////
  115.  
  116. COutputView::~COutputView()
  117. {
  118.     if( NULL != m_hPrinterFont )
  119.     {
  120.         ::DeleteObject( m_hPrinterFont );
  121.     }
  122.  
  123.     delete m_pColoredFont;
  124.     m_pColoredFont = NULL;
  125.  
  126.     delete m_pTrackMenu;
  127.     m_pTrackMenu = NULL;
  128. }
  129.  
  130. /////////////////////////////////////////////////////////////////////////////
  131.  
  132. int COutputView::OnCreate( LPCREATESTRUCT lpCreateStruct )
  133. {
  134.     if( CScrollView::OnCreate( lpCreateStruct ) == -1 )
  135.     {
  136.         return( -1 );
  137.     }
  138.  
  139.     return( 0 );
  140. }
  141.  
  142. /////////////////////////////////////////////////////////////////////////////
  143.  
  144. COutputDoc* COutputView::GetDocument()
  145. { 
  146.     return( (COutputDoc*) m_pDocument ); 
  147. }
  148.  
  149. /////////////////////////////////////////////////////////////////////////////
  150.  
  151. void COutputView::OnInitialUpdate()
  152. {
  153.     CScrollView::OnInitialUpdate();
  154.     UpdateScrollSizes();
  155. }
  156.  
  157. /////////////////////////////////////////////////////////////////////////////
  158.  
  159. void COutputView::OnUpdate( CView* pSender, LPARAM lHint, CObject* pHint )
  160. {
  161.     if( OUTPUTDOC_LINEADDED == lHint )
  162.     {
  163.         COutputLine* pLine = (COutputLine*) pHint;
  164.  
  165.         if( NULL == pLine )
  166.         {
  167.             return;
  168.         }
  169.  
  170.         CClientDC dc( this );
  171.  
  172.         CSize sizeText = dc.GetTabbedTextExtent( (const char*) *pLine, 
  173.                                                  pLine->GetLength(), 
  174.                                                  pLine->GetFormat().GetTabStops(), 
  175.                                                  (int*) pLine->GetFormat().GetTabStopPositionsPixel( dc ) );
  176.  
  177.         m_nRowWidth = max( m_nRowWidth, sizeText.cx );
  178.  
  179.         UpdateScrollSizes();
  180.         
  181.         
  182.         /***
  183.         int nMax = GetDocument()->GetMaxLines();
  184.         int nVis = GetMaxVisibleLines();
  185.  
  186.         if( nMax > nVis )
  187.         {
  188.             ScrollToDevicePosition( CPoint( 0, ( nMax - nVis ) * m_nRowHeight ) );
  189.         }
  190.         ***/
  191.  
  192.         Invalidate();
  193.         SetCurPos( 0, GetDocument()->GetMaxLines() - 1 );
  194.     }
  195.     else if( OUTPUTDOC_CLEARED == lHint )
  196.     {
  197.         m_nSelCol = 0;
  198.         m_nSelCol = 0;
  199.         m_bWhileSelecting = FALSE;
  200.     }
  201. }
  202.  
  203. /////////////////////////////////////////////////////////////////////////////
  204.  
  205. void COutputView::OnPrepareDC( CDC* pDC, CPrintInfo* pInfo )
  206. {
  207.     CScrollView::OnPrepareDC( pDC, pInfo );
  208.  
  209.     if( NULL != pInfo )
  210.     {
  211.         pInfo->m_bContinuePrinting =
  212.             ( (int) pInfo->m_nCurPage <= 
  213.               GetDocument()->GetMaxLines() / m_nPrintLinesPerPage + 1 );
  214.     }
  215. }
  216.  
  217. /////////////////////////////////////////////////////////////////////////////
  218. // COutputView: drawing stuff
  219. /////////////////////////////////////////////////////////////////////////////
  220.  
  221. void COutputView::OnDraw( CDC* pDC )
  222. {
  223.     //-----------------------------------------------------------------------
  224.     // prepare for drawing
  225.     //-----------------------------------------------------------------------
  226.     
  227.     HideCaret();
  228.  
  229.     pDC->SelectObject( *ColoredFontGet() );
  230.     pDC->SetTextColor( *ColoredFontGet() );
  231.  
  232.     //-----------------------------------------------------------------------
  233.     // draw only neccessary lines of document
  234.     //-----------------------------------------------------------------------
  235.     
  236.     int nFirstLine;
  237.     int nLastLine;
  238.     
  239.     CRect rectClip;
  240.     pDC->GetClipBox( &rectClip );
  241.     
  242.     RectToRange( rectClip, nFirstLine, nLastLine );
  243.  
  244.     int y = m_nRowHeight * nFirstLine;
  245.     
  246.     for( int nLine = nFirstLine
  247.          ; 
  248.          nLine <= nLastLine
  249.          ; 
  250.          nLine++, y+= m_nRowHeight )
  251.     {
  252.         OnDrawLine( pDC, nLine, y, FALSE );
  253.     }
  254.  
  255.     ShowCaret();
  256. }
  257.  
  258. /////////////////////////////////////////////////////////////////////////////
  259.  
  260. void COutputView::OnDrawLine( CDC* pDC, int nLine, int y, BOOL bSelected )
  261. {
  262.     //-----------------------------------------------------------------------
  263.     // draw neccessary lines of document
  264.     //-----------------------------------------------------------------------
  265.     
  266.     COutputDoc* pDoc = GetDocument();
  267.     COutputLine& sLine = pDoc->GetLine( nLine );
  268.  
  269.     if( "$LINE" == sLine )
  270.     {
  271.         y += m_nRowHeight / 2;
  272.  
  273.         pDC->MoveTo( 0, y );
  274.         pDC->LineTo( 10000, y );
  275.     }
  276.     else
  277.     {
  278.         int nStartCol, nEndCol;
  279.         GetSelForRow( nLine, nStartCol, nEndCol );
  280.         if( ENDOFLINE == nEndCol )
  281.         {
  282.             nEndCol = sLine.GetLength();
  283.         }
  284.  
  285.         LPCSTR lpszLine = (LPCSTR) sLine;
  286.  
  287.         COLORREF rgbNormalTextColor = pDC->GetTextColor();
  288.         COLORREF rgbNormalBkColor = pDC->GetBkColor();
  289.         
  290.         CSize sizeLeft =
  291.             pDC->TabbedTextOut( 0,
  292.                                 y,
  293.                                 lpszLine,
  294.                                 nStartCol,
  295.                                 sLine.GetFormat().GetTabStops(),
  296.                                 (int*) sLine.GetFormat().GetTabStopPositionsPixel( *pDC ),
  297.                                 0 );
  298.  
  299.         pDC->SetTextColor( rgbNormalBkColor );
  300.         pDC->SetBkColor( rgbNormalTextColor );
  301.  
  302.         CSize sizeMid = 
  303.             pDC->TabbedTextOut( sizeLeft.cx,
  304.                                 y,
  305.                                 lpszLine + nStartCol,
  306.                                 nEndCol - nStartCol,
  307.                                 sLine.GetFormat().GetTabStops(),
  308.                                 (int*) sLine.GetFormat().GetTabStopPositionsPixel( *pDC ),
  309.                                 0 );
  310.  
  311.         pDC->SetTextColor( rgbNormalTextColor );
  312.         pDC->SetBkColor( rgbNormalBkColor );
  313.  
  314.         CSize sizeRight = 
  315.             pDC->TabbedTextOut( sizeLeft.cx + sizeMid.cx,
  316.                                 y,
  317.                                 lpszLine + nEndCol,
  318.                                 sLine.GetLength() - nEndCol,
  319.                                 sLine.GetFormat().GetTabStops(),
  320.                                 (int*) sLine.GetFormat().GetTabStopPositionsPixel( *pDC ),
  321.                                 0 );
  322.     }
  323. }
  324.  
  325. /////////////////////////////////////////////////////////////////////////////
  326.  
  327. void COutputView::OnSize( UINT nType, int cx, int cy )
  328. {
  329.     CScrollView::OnSize( nType, cx, cy );
  330.     
  331.     UpdateScrollSizes();    
  332. }
  333.  
  334. /////////////////////////////////////////////////////////////////////////////
  335.  
  336. void COutputView::UpdateScrollSizes()
  337. {
  338.     //-----------------------------------------------------------------------
  339.     // UpdateScrollSizes() is called when it is necessary to adjust the
  340.     // scrolling range or page/line sizes.  There are two occassions
  341.     // where this is necessary:  (1) when a new row is added-- see
  342.     // OnUpdate()-- and (2) when the window size changes-- see OnSize().
  343.     //-----------------------------------------------------------------------
  344.  
  345.     CRect rectClient;
  346.     GetClientRect( &rectClient );
  347.  
  348.     CClientDC dc( this );
  349.     dc.SelectObject( *ColoredFontGet() );
  350.                 
  351.        TEXTMETRIC tm;
  352.     dc.GetTextMetrics( &tm );
  353.     m_nRowHeight = tm.tmHeight;
  354.  
  355.     //-----------------------------------------------------------------------
  356.     // The vert scrolling range is the total display height of all the rows
  357.     // the horz scrolling range is the width of a row
  358.     //-----------------------------------------------------------------------
  359.     
  360.     CSize sizeTotal( m_nRowWidth + rectClient.right, 
  361.                      m_nRowHeight * GetDocument()->GetMaxLines() );
  362.  
  363.     //-----------------------------------------------------------------------
  364.     // The vertical per-page scrolling distance is equal to the
  365.     // how many rows can be displayed in the current window, less
  366.     // one row for paging overlap.
  367.     //-----------------------------------------------------------------------
  368.     
  369.     m_nMaxVisibleLines = rectClient.bottom / m_nRowHeight;
  370.     
  371.     CSize sizePage( m_nRowWidth / 5,
  372.                     max( m_nRowHeight,
  373.                          m_nRowHeight * m_nMaxVisibleLines ) );
  374.  
  375.     //-----------------------------------------------------------------------
  376.     // The vertical per-line scrolling distance is equal to the
  377.     // height of the row.
  378.     //-----------------------------------------------------------------------
  379.  
  380.     CSize sizeLine( tm.tmMaxCharWidth, m_nRowHeight );
  381.  
  382.     SetScrollSizes( MM_TEXT, sizeTotal, sizePage, sizeLine );
  383. }
  384.  
  385. /////////////////////////////////////////////////////////////////////////////
  386.  
  387. void COutputView::RectToRange( const CRect& rect, int& nFirst, int& nLast )
  388. {
  389.     nFirst = rect.top / m_nRowHeight;
  390.     
  391.     nLast = min( nFirst + rect.Height() / m_nRowHeight + 1,
  392.                  GetDocument()->GetMaxLines() - 1 );
  393. }
  394.  
  395. /////////////////////////////////////////////////////////////////////////////
  396. // COutputView: printing stuff
  397. /////////////////////////////////////////////////////////////////////////////
  398.  
  399. BOOL COutputView::OnPreparePrinting( CPrintInfo* pInfo )
  400. {
  401.     return( DoPreparePrinting( pInfo ) );
  402. }
  403.  
  404. /////////////////////////////////////////////////////////////////////////////
  405.  
  406. void COutputView::OnBeginPrinting( CDC* pDC, CPrintInfo* pInfo )
  407. {
  408.     if( NULL != m_hPrinterFont )
  409.     {
  410.         ::DeleteObject( m_hPrinterFont );
  411.         m_hPrinterFont = NULL;
  412.     }
  413.  
  414.     //-----------------------------------------------------------------------    
  415.     // get display font...
  416.     //-----------------------------------------------------------------------    
  417.     
  418.     CFont* pFont = *ColoredFontGet();
  419.  
  420.     LOGFONT lf;
  421.     pFont->GetObject( sizeof( LOGFONT ), &lf );
  422.  
  423.     //-----------------------------------------------------------------------    
  424.     // ...map to printer font metrics...
  425.     //-----------------------------------------------------------------------    
  426.     
  427.     HDC hDCFrom = ::GetDC( NULL );
  428.     
  429.     lf.lfHeight = ::MulDiv( lf.lfHeight, 
  430.                               pDC->GetDeviceCaps( LOGPIXELSY ),
  431.                               ::GetDeviceCaps( hDCFrom, LOGPIXELSY ) );
  432.     
  433.     lf.lfWidth = 0;
  434. /***              
  435.     lf.lfWidth = ::MulDiv( lf.lfWidth, 
  436.                            pDC->GetDeviceCaps( LOGPIXELSX ),
  437.                            ::GetDeviceCaps( hDCFrom, LOGPIXELSX ) );
  438. ***/
  439.  
  440.     ::ReleaseDC( NULL, hDCFrom );
  441.  
  442.     //-----------------------------------------------------------------------    
  443.     // ...and create font for printing
  444.     //-----------------------------------------------------------------------    
  445.     
  446.     m_hPrinterFont = ::CreateFontIndirect( &lf );
  447.  
  448.     //-----------------------------------------------------------------------    
  449.     // ...and create font for printing
  450.     //-----------------------------------------------------------------------    
  451.     
  452.     pDC->SetMapMode( MM_TEXT );
  453.     pDC->SelectObject( CFont::FromHandle( m_hPrinterFont ) );
  454.     
  455.     TEXTMETRIC tm;
  456.     pDC->GetTextMetrics( &tm );
  457.     
  458.     int nVertRes = pDC->GetDeviceCaps( VERTRES );
  459.     
  460.     m_nPrintRowHeight = tm.tmHeight + tm.tmExternalLeading;
  461.     m_nPrintLinesPerPage = pDC->GetDeviceCaps( VERTRES ) / m_nPrintRowHeight;
  462. }
  463.  
  464. /////////////////////////////////////////////////////////////////////////////
  465.  
  466. void COutputView::OnEndPrinting( CDC*, CPrintInfo* )
  467. {
  468.     if( NULL != m_hPrinterFont  )
  469.     {
  470.         ::DeleteObject( m_hPrinterFont );
  471.         m_hPrinterFont = NULL;
  472.     }
  473.  
  474.     m_nPrintRowHeight = 0;
  475.     m_nPrintLinesPerPage = 0;
  476. }
  477.  
  478. /////////////////////////////////////////////////////////////////////////////
  479.  
  480. void COutputView::OnPrint( CDC* pDC, CPrintInfo* pInfo )
  481. {
  482.     CFont* pOldFont = pDC->SelectObject( CFont::FromHandle( m_hPrinterFont ) );
  483.     pDC->SetBkMode( TRANSPARENT );
  484.  
  485.     int y = 0;
  486.  
  487.     int nPageStartRow = ( pInfo->m_nCurPage - 1 ) * m_nPrintLinesPerPage;
  488.     int nPageMaxEndRow = min( GetDocument()->GetMaxLines(),
  489.                               nPageStartRow + m_nPrintLinesPerPage );
  490.                               
  491.     for( int nLine = nPageStartRow; nLine < nPageMaxEndRow; nLine++ )
  492.     {
  493.         OnDrawLine( pDC, nLine, y, FALSE );
  494.         y+= m_nPrintRowHeight;
  495.     }
  496.     
  497.     pDC->SelectObject( pOldFont );
  498. }
  499.  
  500. /////////////////////////////////////////////////////////////////////////////
  501.  
  502. void COutputView::OnViewFont() 
  503. {
  504.     if( ColoredFontGet()->ChooseColoredFont() )
  505.     {
  506.         InvalidateRect( NULL );
  507.         UpdateScrollSizes();
  508.     }
  509. }
  510.  
  511. /////////////////////////////////////////////////////////////////////////////
  512. // COutputView: caret and cursor stuff
  513. /////////////////////////////////////////////////////////////////////////////
  514.  
  515. BOOL COutputView::OnSetCursor( CWnd* pWnd, UINT nHitTest, UINT message )
  516. {
  517.     if( HTCLIENT == nHitTest )
  518.     {
  519.         ::SetCursor( ::LoadCursor( NULL, MAKEINTRESOURCE( IDC_IBEAM ) ) );
  520.         return( TRUE );
  521.     }
  522.  
  523.     return( CScrollView::OnSetCursor( pWnd, nHitTest, message ) );
  524. }
  525.  
  526. /////////////////////////////////////////////////////////////////////////////
  527.  
  528. void COutputView::OnSetFocus(CWnd* pOldWnd) 
  529. {
  530.     CScrollView::OnSetFocus(pOldWnd);
  531.  
  532. /******
  533.     // we must invalidate active view - otherwise Ctrl-F6 doesn't work
  534.     // after we have activated the output view in Split Mode
  535.  
  536.     CMainFrame* pFrame = (CMainFrame*) AfxGetMainWnd();
  537.     ASSERT( NULL != pFrame );
  538.  
  539.     pFrame->SetActiveView( NULL, FALSE );
  540.     pFrame->OnUpdateFrameMenu( GetDocument()->GetDefaultMenu() );
  541. **********/    
  542.     // caret stuff
  543.     
  544.     ::CreateCaret( m_hWnd, (HBITMAP) NULL, CARET_WIDTH, CARET_HEIGHT ); 
  545.     ShowCaret();
  546.     MoveCaretToCurPos();
  547. }
  548.  
  549. /////////////////////////////////////////////////////////////////////////////
  550.  
  551. void COutputView::OnKillFocus(CWnd* pNewWnd) 
  552. {
  553.     CScrollView::OnKillFocus(pNewWnd);
  554.     
  555.     ::DestroyCaret();
  556.  
  557.     CMainFrame* pFrame = (CMainFrame*) AfxGetMainWnd();
  558.     ASSERT( NULL != pFrame );
  559.     pFrame->OnUpdateFrameMenu( NULL );
  560. }
  561.  
  562. /////////////////////////////////////////////////////////////////////////////
  563.  
  564. void COutputView::OnLButtonDown(UINT nFlags, CPoint point) 
  565. {
  566.     CScrollView::OnLButtonDown( nFlags, point );
  567.  
  568.     BOOL bMoveCaret = TRUE;
  569.     BOOL bClearSelection = !( GetAsyncKeyState( VK_SHIFT ) < 0 );
  570.     
  571.     SetCapture();
  572.     SetCurPos( point, bMoveCaret, bClearSelection );
  573. }
  574.  
  575. /////////////////////////////////////////////////////////////////////////////
  576.  
  577. void COutputView::OnLButtonUp(UINT nFlags, CPoint point) 
  578. {
  579.     CScrollView::OnLButtonUp(nFlags, point);
  580.  
  581.     SetCurPos( point, TRUE, FALSE );
  582.     ReleaseCapture();
  583. }
  584.  
  585. /////////////////////////////////////////////////////////////////////////////
  586.  
  587. void COutputView::OnRButtonUp(UINT nFlags, CPoint point) 
  588. {
  589.     CScrollView::OnRButtonUp(nFlags, point);
  590.  
  591.     MapWindowPoints( NULL, &point, 1 );
  592.  
  593.     CMenu* pTrackPopup = m_pTrackMenu->GetSubMenu( 0 );
  594.  
  595.     if( NULL != pTrackPopup )
  596.     {
  597.         pTrackPopup->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON, 
  598.                                      point.x,
  599.                                      point.y,
  600.                                      this );
  601.     }
  602. }
  603.  
  604. /////////////////////////////////////////////////////////////////////////////
  605.  
  606. void COutputView::OnMouseMove(UINT nFlags, CPoint point) 
  607. {
  608.     CScrollView::OnMouseMove(nFlags, point);
  609.  
  610.     if( !( MK_LBUTTON & nFlags ) )
  611.     {
  612.         return;
  613.     }
  614.  
  615.     // point is restricted to ClientRect
  616.  
  617.     CRect rectClient;
  618.     GetClientRect( rectClient );
  619.  
  620.     point.x = max( min( point.x, rectClient.right ), rectClient.left );
  621.     point.y = max( min( point.y, rectClient.bottom ), rectClient.top );
  622.  
  623.     // set caret - and do scrolling if neccessary..
  624.         
  625.     SetCurPos( point, TRUE, FALSE );
  626. }
  627.  
  628. /////////////////////////////////////////////////////////////////////////////
  629.  
  630. void COutputView::SetCapture()
  631. {
  632.     CScrollView::SetCapture();
  633.  
  634.     m_nIDCaptureTimer = SetTimer( CAPTURE_TIMER, CAPTURE_TIMER_TIMEOUT, NULL );
  635. }
  636.  
  637. void COutputView::ReleaseCapture()
  638. {
  639.     KillTimer( m_nIDCaptureTimer );
  640.     ::ReleaseCapture();
  641. }
  642.  
  643. void COutputView::OnTimer(UINT nIDEvent) 
  644. {
  645.     CScrollView::OnTimer(nIDEvent);
  646.  
  647.     // simulate a mouse move...
  648.  
  649.     CPoint point;
  650.     GetCursorPos( &point );
  651.     ScreenToClient( &point );
  652.  
  653.     UINT nFlags = 0;
  654.  
  655.     if( GetAsyncKeyState( VK_CONTROL ) < 0 )
  656.     {
  657.         nFlags |= MK_CONTROL;
  658.     }
  659.     if( GetAsyncKeyState( VK_LBUTTON ) < 0 )
  660.     {
  661.         nFlags |= MK_LBUTTON;
  662.     }
  663.     if( GetAsyncKeyState( VK_MBUTTON ) < 0 )
  664.     {
  665.         nFlags |= MK_MBUTTON;
  666.     }
  667.     if( GetAsyncKeyState( VK_RBUTTON ) < 0 )
  668.     {
  669.         nFlags |= MK_RBUTTON;
  670.     }
  671.     if( GetAsyncKeyState( VK_SHIFT ) < 0 )
  672.     {
  673.         nFlags |= MK_SHIFT;
  674.     }
  675.  
  676.     OnMouseMove( nFlags, point );
  677. }
  678.  
  679. /////////////////////////////////////////////////////////////////////////////
  680.  
  681. void COutputView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  682. {
  683.     CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
  684.  
  685.     BOOL bMoveCaret = TRUE;
  686.     BOOL bClearSelection = !( GetAsyncKeyState( VK_SHIFT ) < 0 );
  687.  
  688.     switch( nChar )
  689.     {
  690.         case VK_HOME:
  691.             if( GetAsyncKeyState( VK_CONTROL ) < 0 )
  692.             {
  693.                 SetCurPos( 0, 0, bMoveCaret, bClearSelection );
  694.             }
  695.             else
  696.             {
  697.                 SetCurPos( 0, CURRENT_VALUE, bMoveCaret, bClearSelection );
  698.             }
  699.             break; 
  700.  
  701.         case VK_END:
  702.             if( GetAsyncKeyState( VK_CONTROL ) < 0 )
  703.             {
  704.                 SetCurPos( ENDOFLINE, ENDOFLINES, bMoveCaret, bClearSelection );
  705.             }
  706.             else
  707.             {
  708.                 SetCurPos( ENDOFLINE, CURRENT_VALUE, bMoveCaret, bClearSelection );
  709.             }
  710.             break; 
  711.  
  712.         case VK_PRIOR:
  713.         {
  714.             CPoint pt = GetCaretPos();
  715.             pt.y -= ( ( m_nMaxVisibleLines - 1 ) * m_nRowHeight );
  716.             SetCurPos( pt, bMoveCaret, bClearSelection );
  717.             break; 
  718.         }    
  719.         case VK_NEXT:
  720.         {
  721.             CPoint pt = GetCaretPos();
  722.             pt.y += ( ( m_nMaxVisibleLines - 1 ) * m_nRowHeight );
  723.             SetCurPos( pt, bMoveCaret, bClearSelection );
  724.             break; 
  725.         }    
  726.         case VK_LEFT:
  727.             SetCurPos( GetCurCol() - 1, CURRENT_VALUE, bMoveCaret, bClearSelection );
  728.             break; 
  729.  
  730.         case VK_RIGHT:
  731.             SetCurPos( GetCurCol() + 1, CURRENT_VALUE, bMoveCaret, bClearSelection );
  732.             break; 
  733.  
  734.         case VK_UP:
  735.         {
  736.             CPoint pt = GetCaretPos();
  737.             pt.y -= m_nRowHeight;
  738.             SetCurPos( pt, bMoveCaret, bClearSelection );
  739.             break; 
  740.         }
  741.         case VK_DOWN:
  742.         {
  743.             CPoint pt = GetCaretPos();
  744.             pt.y += m_nRowHeight;
  745.             SetCurPos( pt, bMoveCaret, bClearSelection );
  746.             break; 
  747.         }
  748.     }
  749. }
  750.  
  751. /////////////////////////////////////////////////////////////////////////////
  752.  
  753. CPoint COutputView::VirtCharPosFromCoords( int nCol, int nRow )
  754. {
  755.     CClientDC dc( this );
  756.     dc.SelectObject( *ColoredFontGet() );
  757.  
  758.     COutputLine& sLine = GetDocument()->GetLine( nRow );
  759.  
  760.     if( nCol > sLine.GetLength() )
  761.     {
  762.         nCol = sLine.GetLength();
  763.     }
  764.     
  765.     CSize size = dc.GetTabbedTextExtent( (const char*) sLine, 
  766.                                          nCol, 
  767.                                          sLine.GetFormat().GetTabStops(), 
  768.                                          (int*) sLine.GetFormat().GetTabStopPositionsPixel( dc ) );
  769.  
  770.     return( CPoint( size.cx, nRow * m_nRowHeight ) );
  771. }
  772.  
  773. /////////////////////////////////////////////////////////////////////////////
  774.  
  775. void COutputView::CharCoordsFromVirtPoint( CPoint pt, int& nCol, int& nRow )
  776. {
  777.     nCol = 0;
  778.     nRow = min( pt.y / m_nRowHeight, GetDocument()->GetMaxLines() - 1 );
  779.     nRow = max( nRow, 0 );
  780.  
  781.     COutputLine& sLine = GetDocument()->GetLine( nRow );
  782.  
  783.     CClientDC dc( this );
  784.     dc.SelectObject( *ColoredFontGet() );
  785.  
  786.     while( nCol < sLine.GetLength() )
  787.     {
  788.         CSize size = dc.GetTabbedTextExtent( (const char*) sLine, 
  789.                                              nCol + 1,
  790.                                              sLine.GetFormat().GetTabStops(), 
  791.                                              (int*) sLine.GetFormat().GetTabStopPositionsPixel( dc ) );
  792.  
  793.         if( size.cx > pt.x ) 
  794.         {
  795.             break;
  796.         }
  797.  
  798.         nCol++;
  799.     }
  800. }
  801.  
  802. /////////////////////////////////////////////////////////////////////////////
  803.  
  804. void COutputView::SetCurPos( int nCol, int nRow, BOOL bMoveCaret, BOOL bClearSelection )
  805. {
  806.     // convienince values
  807.  
  808.     if( CURRENT_VALUE == nCol )
  809.     {
  810.         nCol = m_nCurCol;
  811.     }
  812.  
  813.     if( CURRENT_VALUE == nRow )
  814.     {
  815.         nRow = m_nCurRow;
  816.     }
  817.  
  818.     // check and correct position values
  819.  
  820.     nRow = min( nRow, GetDocument()->GetMaxLines() - 1 );
  821.     nRow = max( nRow, 0 );
  822.  
  823.     COutputLine& sLine = GetDocument()->GetLine( nRow );
  824.  
  825.     nCol = min( nCol, sLine.GetLength() );
  826.     nCol = max( nCol, 0 );
  827.  
  828.     // check for selection
  829.  
  830.     if( bClearSelection )
  831.     {
  832.         if( m_bWhileSelecting )
  833.         {
  834.             InvalidateSelRange();
  835.             m_bWhileSelecting = FALSE;
  836.         }
  837.  
  838.         m_nSelCol = nCol;
  839.         m_nSelRow = nRow;
  840.     }
  841.     else
  842.     {
  843.         m_bWhileSelecting = TRUE;
  844.         InvalidateNewRange( nCol, nRow );
  845.     }
  846.  
  847.     // now remember position
  848.  
  849.     m_nCurCol = nCol;
  850.     m_nCurRow = nRow;
  851.  
  852.     // move the caret if neccessary
  853.  
  854.     if( bMoveCaret )
  855.     {
  856.         MoveCaretToCurPos();
  857.     }
  858. }
  859.  
  860. /////////////////////////////////////////////////////////////////////////////
  861.  
  862. void COutputView::SetCurPos( CPoint pt, BOOL bMoveCaret, BOOL bClearSelection )
  863. {
  864.     pt.x += GetDeviceScrollPosition().x;
  865.     pt.y += GetDeviceScrollPosition().y;
  866.  
  867.     int nCol;
  868.     int nRow;
  869.  
  870.     CharCoordsFromVirtPoint( pt, nCol, nRow );
  871.  
  872.     SetCurPos( nCol, nRow, bMoveCaret, bClearSelection );
  873. }
  874.  
  875. /////////////////////////////////////////////////////////////////////////////
  876.  
  877. void COutputView::MoveCaretToCurPos()
  878. {
  879.     HideCaret();
  880.     CPoint ptCaret = GetCaretPos();
  881.     InvalidateRect( CRect( ptCaret, CSize( CARET_WIDTH, CARET_HEIGHT ) ) );
  882.     
  883.     CPoint pt = VirtCharPosFromCoords( m_nCurCol, m_nCurRow );
  884.     AdjustScrollToVirtPoint( pt );
  885.  
  886.     pt.x -= GetDeviceScrollPosition().x;
  887.     pt.y -= GetDeviceScrollPosition().y;
  888.     
  889.     SetCaretPos( pt );
  890.  
  891.     ShowCaret();
  892. }
  893.  
  894. /////////////////////////////////////////////////////////////////////////////
  895.  
  896. CString COutputView::GetCurRowAsString()
  897. {
  898.     return( GetDocument()->GetLine( m_nCurRow ) );
  899. }
  900.  
  901. /////////////////////////////////////////////////////////////////////////////
  902.  
  903. BOOL COutputView::GetSelForRow( int nRow, int& nStartCol, int& nEndCol ) const
  904. {
  905.     nStartCol = 0;
  906.     nEndCol = 0;
  907.  
  908.     int nSelStartCol, nSelEndCol, nSelStartRow, nSelEndRow;
  909.     GetSelRange( nSelStartCol, nSelStartRow, nSelEndCol, nSelEndRow );
  910.  
  911.     if( ( nRow < nSelStartRow ) || ( nRow > nSelEndRow ) )
  912.     {
  913.         return( FALSE );
  914.     }
  915.  
  916.     if( nRow == nSelStartRow )
  917.     {
  918.         nStartCol = nSelStartCol;
  919.     }
  920.  
  921.     if( nRow == nSelEndRow )
  922.     {
  923.         nEndCol = nSelEndCol;
  924.     }
  925.     
  926.     if( nRow < nSelEndRow )
  927.     {
  928.         nEndCol = ENDOFLINE;
  929.     }
  930.  
  931.     return( TRUE );
  932. }
  933.  
  934. /////////////////////////////////////////////////////////////////////////////
  935.  
  936. void COutputView::InvalidateSelRange()
  937. {
  938.     int nStartCol, nStartRow, nEndCol, nEndRow;
  939.     GetSelRange( nStartCol, nStartRow, nEndCol, nEndRow );
  940.  
  941.     InvalidateRange( nStartCol, nStartRow, nEndCol, nEndRow );
  942. }
  943.  
  944. void COutputView::InvalidateNewRange( int nCol, int nRow )
  945. {
  946.     int nStartCol, nStartRow, nEndCol, nEndRow;
  947.  
  948.     if( m_nCurRow < nRow )
  949.     {
  950.         nStartRow = m_nCurRow;
  951.         nStartCol = m_nCurCol;
  952.  
  953.         nEndRow = nRow;
  954.         nEndCol = nCol;
  955.     }
  956.     else if( m_nCurRow > nRow )
  957.     {
  958.         nStartRow = nRow;
  959.         nStartCol = nCol;
  960.  
  961.         nEndRow = m_nCurRow;
  962.         nEndCol = m_nCurCol;
  963.     }
  964.     else
  965.     {
  966.         nStartRow = nRow;
  967.         nStartCol = min( m_nCurCol, nCol );
  968.  
  969.         nEndRow = m_nCurRow;
  970.         nEndCol = max( m_nCurCol, nCol );
  971.     }
  972.  
  973.     InvalidateRange( nStartCol, nStartRow, nEndCol, nEndRow );
  974. }
  975.  
  976. void COutputView::InvalidateRange( int nStartCol, int nStartRow, int nEndCol, int nEndRow )
  977. {
  978.     if( !::IsWindow( m_hWnd ) )
  979.     {
  980.         return;
  981.     }
  982.  
  983.     CPoint ptScroll = GetDeviceScrollPosition();
  984.     
  985.     CPoint ptStart = VirtCharPosFromCoords( nStartCol, nStartRow );
  986.     ptStart.x -= ptScroll.x;
  987.     ptStart.y -= ptScroll.y;
  988.  
  989.     CPoint ptEnd = VirtCharPosFromCoords( nEndCol, nEndRow );
  990.     ptEnd.x -= ptScroll.x;
  991.     ptEnd.y -= ptScroll.y;
  992.  
  993.     CRect rect;
  994.     rect.top = ptStart.y;
  995.     rect.bottom = ptEnd.y + m_nRowHeight;
  996.  
  997.     if( nStartRow == nEndRow )
  998.     {
  999.         rect.left = ptStart.x;
  1000.         rect.right = ptEnd.x;
  1001.     }
  1002.     else
  1003.     {
  1004.         CRect rectClient;
  1005.         GetClientRect( rectClient );
  1006.  
  1007.         rect.left = 0;
  1008.         rect.right = rectClient.Width();
  1009.     }
  1010.     
  1011.     InvalidateRect( rect, FALSE );
  1012. }
  1013.     
  1014. /////////////////////////////////////////////////////////////////////////////
  1015.  
  1016. BOOL COutputView::GetSelRange( int& nSelStartCol, int& nSelStartRow, int& nSelEndCol, int& nSelEndRow ) const
  1017. {
  1018.     if( m_nCurRow < m_nSelRow )
  1019.     {
  1020.         nSelStartRow = m_nCurRow;
  1021.         nSelStartCol = m_nCurCol;
  1022.  
  1023.         nSelEndRow = m_nSelRow;
  1024.         nSelEndCol = m_nSelCol;
  1025.     }
  1026.     else if( m_nCurRow > m_nSelRow )
  1027.     {
  1028.         nSelStartRow = m_nSelRow;
  1029.         nSelStartCol = m_nSelCol;
  1030.  
  1031.         nSelEndRow = m_nCurRow;
  1032.         nSelEndCol = m_nCurCol;
  1033.     }
  1034.     else
  1035.     {
  1036.         nSelStartRow = m_nSelRow;
  1037.         nSelStartCol = min( m_nCurCol, m_nSelCol );
  1038.  
  1039.         nSelEndRow = m_nCurRow;
  1040.         nSelEndCol = max( m_nCurCol, m_nSelCol );
  1041.     }
  1042.  
  1043.     return( ( nSelStartCol != nSelEndRow ) || ( nSelStartCol != nSelEndCol ) );
  1044. }
  1045.  
  1046. /////////////////////////////////////////////////////////////////////////////
  1047.  
  1048. void COutputView::GetSelectedText( CString& strResult )
  1049. {
  1050.     int nSelStartCol, nSelEndCol, nSelStartRow, nSelEndRow;
  1051.     GetSelRange( nSelStartCol, nSelStartRow, nSelEndCol, nSelEndRow );
  1052.  
  1053.     if( nSelStartRow == nSelEndRow )
  1054.     {
  1055.         strResult = GetDocument()->GetLine( nSelStartRow ).Mid( nSelStartCol, nSelEndCol - nSelStartCol );
  1056.     }
  1057.     else
  1058.     {
  1059.         strResult = GetDocument()->GetLine( nSelStartRow ).Mid( nSelStartCol );
  1060.  
  1061.         for( int nRow = nSelStartRow + 1; nRow < nSelEndRow; nRow++ )
  1062.         {
  1063.             strResult += CString( "\r\n" );
  1064.             strResult += GetDocument()->GetLine( nRow );
  1065.         }
  1066.  
  1067.         strResult += CString( "\r\n" );
  1068.         strResult += GetDocument()->GetLine( nSelEndRow ).Left( nSelEndCol );
  1069.     }
  1070. }
  1071.  
  1072. /////////////////////////////////////////////////////////////////////////////
  1073.  
  1074. void COutputView::AdjustScrollToVirtPoint( CPoint ptVirt )
  1075. {
  1076.     CPoint ptScroll = GetDeviceScrollPosition();
  1077.     CPoint ptCaret = ptVirt - ptScroll;
  1078.     CRect rectCaret( ptCaret, CSize( CARET_WIDTH, CARET_HEIGHT ) );
  1079.  
  1080.     CRect rectClient;
  1081.     GetClientRect( rectClient );
  1082.  
  1083.     // rectCaret fully contained in rectClient ??
  1084.     
  1085.     CRect rectIntersect;
  1086.     rectIntersect.IntersectRect( rectClient, rectCaret );
  1087.  
  1088.     if( rectCaret == rectIntersect )
  1089.     {
  1090.         return;
  1091.     }
  1092.  
  1093.     int nMapMode;
  1094.     CSize sizeTotal, sizePage, sizeLine;
  1095.  
  1096.     GetDeviceScrollSizes( nMapMode, sizeTotal, sizePage, sizeLine );
  1097.     //sizePage.cx -= sizeLine.cx;
  1098.     //sizePage.cy -= sizeLine.cy;
  1099.     
  1100.     // maybe scroll a char to the left
  1101.  
  1102.     if( ( rectCaret.left < rectClient.left ) && ( rectCaret.left >= rectClient.left - sizeLine.cx ) &&
  1103.         ( rectCaret.top >= rectClient.top ) && ( rectCaret.bottom <= rectClient.bottom ) )
  1104.     {
  1105.         ptScroll.x -= sizeLine.cx;
  1106.     }
  1107.  
  1108.     // maybe scroll a char to the right
  1109.  
  1110.     else if( ( rectCaret.right > rectClient.right ) && ( rectCaret.right <= rectClient.right + sizeLine.cx ) &&
  1111.              ( rectCaret.top >= rectClient.top ) && ( rectCaret.bottom <= rectClient.bottom ) )
  1112.     {
  1113.         ptScroll.x += sizeLine.cx;
  1114.     }
  1115.  
  1116.     // maybe scroll a page to the left
  1117.  
  1118.     else if( ( rectCaret.left < rectClient.left ) && ( rectCaret.left > rectClient.left - sizePage.cx ) &&
  1119.              ( rectCaret.top >= rectClient.top ) && ( rectCaret.bottom <= rectClient.bottom ) )
  1120.  
  1121.     {
  1122.         ptScroll.x -= sizePage.cx;
  1123.     }
  1124.  
  1125.     // maybe scroll a page to the right
  1126.  
  1127.     else if( ( rectCaret.right > rectClient.right ) && ( rectCaret.right < rectClient.right + sizePage.cx ) &&
  1128.              ( rectCaret.top >= rectClient.top ) && ( rectCaret.bottom <= rectClient.bottom ) )
  1129.  
  1130.     {
  1131.         ptScroll.x += sizePage.cx;
  1132.     }
  1133.  
  1134.     // maybe scroll a line up
  1135.         
  1136.     else if( ( rectCaret.top < rectClient.top ) && ( rectCaret.top >= rectClient.top - sizeLine.cy ) &&
  1137.              ( rectCaret.left >= rectClient.left ) && ( rectCaret.right <= rectClient.right ) )
  1138.  
  1139.     {
  1140.         ptScroll.y -= sizeLine.cy;
  1141.     }
  1142.  
  1143.     // maybe scroll a line down
  1144.         
  1145.     else if( ( rectCaret.bottom > rectClient.bottom ) && ( rectCaret.bottom <= rectClient.bottom + sizeLine.cy ) &&
  1146.              ( rectCaret.left >= rectClient.left ) && ( rectCaret.right <= rectClient.right ) )
  1147.     {
  1148.         ptScroll.y += sizeLine.cy;
  1149.     }
  1150.  
  1151.     // maybe scroll a page up
  1152.  
  1153.     else if( ( rectCaret.top < rectClient.top ) && ( rectCaret.top > rectClient.top - sizePage.cy ) &&
  1154.              ( rectCaret.left >= rectClient.left ) && ( rectCaret.right <= rectClient.right ) )
  1155.     {
  1156.         ptScroll.y -= sizePage.cy;
  1157.     }
  1158.  
  1159.     // maybe scroll a page down
  1160.  
  1161.     else if( ( rectCaret.bottom > rectClient.bottom ) && ( rectCaret.bottom < rectClient.bottom + sizePage.cy ) &&
  1162.              ( rectCaret.left >= rectClient.left ) && ( rectCaret.right <= rectClient.right ) )
  1163.     {
  1164.         ptScroll.y += sizePage.cy;
  1165.     }
  1166.  
  1167.     // otherwise position direct
  1168.  
  1169.     else
  1170.     {
  1171.         ptScroll = ptVirt;
  1172.  
  1173.         // as far left as possible
  1174.  
  1175.         ptScroll.x -= ( rectClient.Width() - sizeLine.cx );
  1176.         ptScroll.x = max( 0, ptScroll.x );
  1177.     }
  1178.  
  1179.     ptScroll.x = max( 0, ptScroll.x );
  1180.     ptScroll.y = max( 0, ptScroll.y );
  1181.  
  1182.     ScrollToDevicePosition( ptScroll );
  1183. }
  1184.  
  1185. /////////////////////////////////////////////////////////////////////////////
  1186.  
  1187. void COutputView::OnEditCopy() 
  1188. {
  1189.     CString sSelText;
  1190.     GetSelectedText( sSelText );
  1191.  
  1192.     if( ::OpenClipboard( m_hWnd ) )
  1193.     {
  1194.         HGLOBAL hData = ::GlobalAlloc( GHND, sSelText.GetLength() + 1 );
  1195.         char* psz = (char*) ::GlobalLock( hData );
  1196.         ASSERT( NULL != psz );
  1197.         strcpy( psz, (const char*) sSelText );
  1198.         ::GlobalUnlock( hData );
  1199.         
  1200.         ::SetClipboardData( CF_TEXT, hData );
  1201.         ::CloseClipboard();
  1202.     }
  1203. }
  1204.  
  1205. /////////////////////////////////////////////////////////////////////////////
  1206.  
  1207. void COutputView::OnUpdateEditCopy(CCmdUI* pCmdUI) 
  1208. {
  1209.     int nSelStartCol, nSelEndCol, nSelStartRow, nSelEndRow;
  1210.     GetSelRange( nSelStartCol, nSelStartRow, nSelEndCol, nSelEndRow );
  1211.  
  1212.     pCmdUI->Enable( ( nSelStartRow != nSelEndRow ) || ( nSelStartCol != nSelEndCol ) );
  1213. }
  1214.