home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / MSGTRACE.ZIP / MyProjects / MsgTrace / MsgTracer / OutputLine.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-30  |  6.7 KB  |  269 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. // File        : OutputLine.cpp
  4. // Project     : MsgTrace
  5. // Component   : MsgTracer
  6. //---------------------------------------------------------------------------
  7. // Description : output-line
  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. #include "OutputLine.h"
  21.  
  22. /////////////////////////////////////////////////////////////////////////////
  23.  
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char BASED_CODE THIS_FILE[] = __FILE__;
  27. #endif
  28.  
  29. /////////////////////////////////////////////////////////////////////////////
  30. //
  31. //                            COutputLine
  32. //
  33. /////////////////////////////////////////////////////////////////////////////
  34.  
  35. COutputLineFormat COutputLine::m_aDefaultFormat;
  36.  
  37. /////////////////////////////////////////////////////////////////////////////
  38. // COutputLine: construction
  39. /////////////////////////////////////////////////////////////////////////////
  40.  
  41. COutputLine::COutputLine() : m_pFormat( NULL )
  42. {
  43. }
  44.  
  45. /////////////////////////////////////////////////////////////////////////////
  46.  
  47. COutputLine::COutputLine( const CString& sText ) : CString( sText ), m_pFormat( NULL )
  48. {
  49. }
  50.  
  51. /////////////////////////////////////////////////////////////////////////////
  52.  
  53. COutputLine::COutputLine( LPCSTR pszText ) : CString( pszText ), m_pFormat( NULL )
  54. {
  55. }
  56.  
  57. /////////////////////////////////////////////////////////////////////////////
  58.  
  59. COutputLine::COutputLine( const COutputLine& aToCopy ) : CString( aToCopy )
  60. {
  61.     if( NULL == aToCopy.m_pFormat )
  62.     {
  63.         m_pFormat = NULL;
  64.     }
  65.     else
  66.     {
  67.         m_pFormat = new COutputLineFormat( *aToCopy.m_pFormat );
  68.     }
  69. }
  70.  
  71. /////////////////////////////////////////////////////////////////////////////
  72.  
  73. COutputLine::~COutputLine()
  74. {
  75.     delete m_pFormat;
  76.     m_pFormat = NULL;
  77. }
  78.  
  79. /////////////////////////////////////////////////////////////////////////////
  80. // COutputLine: operators
  81. /////////////////////////////////////////////////////////////////////////////
  82.  
  83. COutputLine& COutputLine::operator=( const COutputLine& aToCopy )
  84. {
  85.     if( this != &aToCopy )
  86.     {
  87.         CString::operator=( aToCopy );
  88.         SetFormat( aToCopy.GetFormat() );
  89.     }
  90.  
  91.     return( *this );
  92. }
  93.  
  94. /////////////////////////////////////////////////////////////////////////////
  95.  
  96. COutputLine& COutputLine::operator=( const CString& sToCopy )
  97. {
  98.     CString::operator=( sToCopy );
  99.  
  100.     return( *this );
  101. }
  102.  
  103. /////////////////////////////////////////////////////////////////////////////
  104.  
  105. COutputLine& COutputLine::operator=( LPCSTR lpszToCopy )
  106. {
  107.     CString::operator=( lpszToCopy );
  108.  
  109.     return( *this );
  110. }
  111.  
  112. /////////////////////////////////////////////////////////////////////////////
  113. // COutputLine: format
  114. /////////////////////////////////////////////////////////////////////////////
  115.  
  116. void COutputLine::SetFormat( const COutputLineFormat& aFormatToSet )
  117. {
  118.     delete m_pFormat;
  119.     m_pFormat = NULL;
  120.  
  121.     if( &m_aDefaultFormat != &aFormatToSet )
  122.     {
  123.         m_pFormat = new COutputLineFormat( aFormatToSet );
  124.     }
  125. }
  126.  
  127. /////////////////////////////////////////////////////////////////////////////
  128.  
  129. const COutputLineFormat& COutputLine::GetFormat() const
  130. {
  131.     if( NULL == m_pFormat )
  132.     {
  133.         return( m_aDefaultFormat );
  134.     }
  135.     else
  136.     {
  137.         return( *m_pFormat );
  138.     }
  139. }
  140.  
  141.  
  142. /////////////////////////////////////////////////////////////////////////////
  143. //
  144. //                            COutputLineFormat
  145. //
  146. /////////////////////////////////////////////////////////////////////////////
  147.  
  148. /////////////////////////////////////////////////////////////////////////////
  149. // COutputLineFormat: construction
  150. /////////////////////////////////////////////////////////////////////////////
  151.  
  152. COutputLineFormat::COutputLineFormat() :
  153.  
  154.     m_nTabStops( 0 ),
  155.     m_pnTabStopPositions( NULL )
  156.  
  157. {
  158. }
  159.  
  160. /////////////////////////////////////////////////////////////////////////////
  161.  
  162. COutputLineFormat::COutputLineFormat( const COutputLineFormat& aToCopy ) :
  163.  
  164.     m_nTabStops( 0 ),
  165.     m_pnTabStopPositions( NULL )
  166.  
  167. {
  168.     InitTabStops( aToCopy.GetTabStops(), aToCopy.GetTabStopPositions() );
  169. }
  170.  
  171. /////////////////////////////////////////////////////////////////////////////
  172.  
  173. COutputLineFormat::~COutputLineFormat()
  174. {
  175.     delete [] m_pnTabStopPositions;
  176.     m_pnTabStopPositions = NULL;
  177. }
  178.  
  179. /////////////////////////////////////////////////////////////////////////////
  180. // COutputLineFormat: operators
  181. /////////////////////////////////////////////////////////////////////////////
  182.  
  183. COutputLineFormat& COutputLineFormat::operator=( const COutputLineFormat& aToCopy )
  184. {
  185.     InitTabStops( aToCopy.GetTabStops(), aToCopy.GetTabStopPositions() );
  186.     return( *this );
  187. }
  188.  
  189. /////////////////////////////////////////////////////////////////////////////
  190. // COutputLineFormat: tab-stops
  191. /////////////////////////////////////////////////////////////////////////////
  192.  
  193. void COutputLineFormat::InitTabStops( int nTabStops, const int* pnTabStopPositions )
  194. {
  195.     delete [] m_pnTabStopPositions;
  196.     m_pnTabStopPositions = NULL;
  197.  
  198.     m_nTabStops = nTabStops;
  199.  
  200.     if( 0 < m_nTabStops )
  201.     {
  202.         m_pnTabStopPositions = new int[ m_nTabStops ];
  203.  
  204.         if( NULL != pnTabStopPositions )
  205.         {
  206.             ::CopyMemory( m_pnTabStopPositions,
  207.                           pnTabStopPositions,
  208.                           m_nTabStops * sizeof( int ) );
  209.         }
  210.         else
  211.         {
  212.             ::ZeroMemory( m_pnTabStopPositions, 
  213.                           m_nTabStops * sizeof( int ) );
  214.         }
  215.     }    
  216. }
  217.  
  218. /////////////////////////////////////////////////////////////////////////////
  219.  
  220. void COutputLineFormat::SetTabStop( int nIndex, int nTabPos )
  221. {
  222.     if( ( nIndex < 0 ) || ( nIndex >= m_nTabStops ) )
  223.     {
  224.         return;
  225.     }
  226.  
  227.     m_pnTabStopPositions[ nIndex ] = nTabPos;
  228. }
  229.  
  230. /////////////////////////////////////////////////////////////////////////////
  231.  
  232. int COutputLineFormat::GetTabStops() const
  233. {
  234.     return( m_nTabStops );
  235. }
  236.  
  237. /////////////////////////////////////////////////////////////////////////////
  238.  
  239. const int* COutputLineFormat::GetTabStopPositions() const
  240. {
  241.     return( m_pnTabStopPositions );
  242. }
  243.  
  244. /////////////////////////////////////////////////////////////////////////////
  245.  
  246. const int* COutputLineFormat::GetTabStopPositionsPixel( const CDC& dc ) const
  247. {
  248.     static int* pnTemp = NULL;
  249.  
  250.     delete [] pnTemp;
  251.     pnTemp = NULL;
  252.  
  253.     if( 0 < m_nTabStops )
  254.     {
  255.         pnTemp = new int[ m_nTabStops ];
  256.         ::CopyMemory( pnTemp, m_pnTabStopPositions, m_nTabStops * sizeof( int ) );
  257.         
  258.         TEXTMETRIC tm;
  259.         dc.GetTextMetrics( &tm );
  260.  
  261.         for( int nIndex = 0; nIndex < m_nTabStops; nIndex++ )
  262.         {
  263.             pnTemp[ nIndex ] *= tm.tmAveCharWidth;
  264.         }
  265.     }
  266.  
  267.     return( pnTemp );
  268. }
  269.