home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / starview / inc / tools.hxx < prev   
Encoding:
Text File  |  1992-08-01  |  27.6 KB  |  823 lines
  1. /*************************************************************************
  2. * TOOLS.HXX
  3. * (c) 1992 STAR DIVISION
  4. *************************************************************************/
  5. #ifndef _TOOLS_HXX
  6. #define _TOOLS_HXX
  7. #define E2I
  8. #ifndef _SOLAR_H
  9. #include "solar.h"
  10. #endif
  11.  
  12. #ifndef _TOOLS_H
  13. #define _TOOLS_H
  14.  
  15. #ifndef _SOLAR_H
  16. #endif
  17.  
  18. #endif 
  19.  
  20. #ifndef _LINK_HXX
  21. #define _LINK_HXX
  22.  
  23. #ifndef _TOOLS_H
  24. #endif
  25.  
  26. class LinkHdl
  27. {
  28. #ifdef _MSC_VER
  29.     virtual void MakeVTabForMSC();
  30. #endif
  31. };
  32.  
  33. typedef long (LinkHdl::*PFUNC)( void* pCaller );
  34.  
  35. class Link
  36. {
  37. protected:
  38.     LinkHdl*  pInst;
  39.     PFUNC     pMemFunc;
  40.  
  41. public:
  42.               Link();
  43.               Link( LinkHdl* pFuncOwner, PFUNC pProc );
  44.  
  45.     long      Call( void* pCaller )
  46.                   { return( (pInst && pMemFunc) ?
  47.                             (pInst->*pMemFunc)( pCaller ) : 0 ); }
  48.  
  49.     BOOL      IsSet() const { return (pInst && pMemFunc); }
  50.  
  51.     BOOL      operator==( const Link& rLink ) const;
  52.     BOOL      operator!=( const Link& rLink ) const;
  53. };
  54.  
  55. #ifdef _MSC_VER
  56. #define NEWLINK
  57. #endif
  58.  
  59. #ifdef NEWLINK
  60.  
  61. #define LINK( pInst, Class, pMemFunc ) \
  62.             Link( (LinkHdl*)pInst, \
  63.             (PFUNC)(long (Class::*)( void* )) &Class::pMemFunc )
  64.  
  65. #else
  66.  
  67. #define LINK( pInst, pMemFunc ) Link( pInst, (PFUNC)&pMemFunc )
  68.  
  69. #endif
  70.  
  71. #endif  
  72.  
  73. #define _PAIR Pair
  74. #define _POINT Point
  75. #define _SIZE Size
  76. #define _RANGE Range
  77. #define _SELECTION Selection
  78. #define _RECTANGLE Rectangle
  79.  
  80. #define _PAIR_2 LPair
  81. #define _POINT_2 LPoint
  82. #define _SIZE_2 LSize
  83. #define _RANGE_2 LRange
  84. #define _SELECTION_2 LSelection
  85. #define _RECTANGLE_2 LRectangle
  86.  
  87. #define _SL_TYPE short
  88.  
  89. #define RANGE_MIN   ((short)0x8000)
  90. #define RANGE_MAX   0x7FFF
  91.  
  92. #define SELECTION_MIN   ((short)0x8000)
  93. #define SELECTION_MAX   0x7FFF
  94.  
  95. #ifndef _TOOLS_H
  96. #endif
  97.  
  98. class _PAIR_2;
  99. class _POINT_2;
  100. class _SIZE_2;
  101. class _RANGE_2;
  102. class _SELECTION_2;
  103. class _RECTANGLE_2;
  104.  
  105. class _PAIR
  106. {
  107. protected:
  108.     _SL_TYPE     nA;
  109.     _SL_TYPE     nB;
  110.  
  111. public:
  112.     _PAIR() { nA = 0; nB = 0; }
  113.     _PAIR( const _PAIR& rPair );
  114.     _PAIR( _SL_TYPE nA, _SL_TYPE nB ) { _PAIR::nA = nA; _PAIR::nB = nB; }
  115.     _PAIR( const _PAIR_2& rPair );
  116.  
  117.     _SL_TYPE     A() const { return nA; }
  118.     _SL_TYPE     B() const { return nB; }
  119.  
  120.     _SL_TYPE&    A() { return nA; }
  121.     _SL_TYPE&    B() { return nB; }
  122.  
  123.     BOOL      operator == ( const _PAIR& rPair ) const
  124.               { return ( nA == rPair.A() ) && ( nB == rPair.B() ); }
  125.     BOOL      operator != ( const _PAIR& rPair ) const
  126.               { return ( nA != rPair.A() ) || ( nB != rPair.B() ); }
  127.  
  128.     _PAIR&     operator = ( const _PAIR& rPair );
  129.     _PAIR&     operator = ( const _PAIR_2& rPair );
  130. };
  131.  
  132. class _POINT : public _PAIR
  133. {
  134. public:
  135.     _POINT() {}
  136.     _POINT( const _POINT& rPOINT );
  137.     _POINT( _SL_TYPE nX, _SL_TYPE nY ) : _PAIR( nX, nY ) {}
  138.     _POINT( const _POINT_2& rPoint );
  139.  
  140.     _POINT&     operator += ( const _POINT& rPoint );
  141.     _POINT&     operator -= ( const _POINT& rPoint );
  142.     _POINT&     operator *= ( const _SL_TYPE nVal );
  143.     _POINT&     operator /= ( const _SL_TYPE nVal );
  144.  
  145.     friend _POINT operator+( const _POINT &rVal1, const _POINT &rVal2 );
  146.     friend _POINT operator-( const _POINT &rVal1, const _POINT &rVal2 );
  147.     friend _POINT operator*( const _POINT &rVal1, const _SL_TYPE nVal2 );
  148.     friend _POINT operator/( const _POINT &rVal1, const _SL_TYPE nVal2 );
  149.  
  150.     _SL_TYPE    X() const { return nA; }
  151.     _SL_TYPE    Y() const { return nB; }
  152.  
  153.     _SL_TYPE&   X() { return nA; }
  154.     _SL_TYPE&   Y() { return nB; }
  155.  
  156.     BOOL IsAbove( const _POINT& rPoint ) const { return nB > rPoint.nB; }
  157.     BOOL IsBelow( const _POINT& rPoint ) const { return nB < rPoint.nB; }
  158.     BOOL IsLeft( const _POINT& rPoint ) const { return nA < rPoint.nA; }
  159.     BOOL IsRight( const _POINT& rPoint ) const { return nA > rPoint.nA; }
  160. };
  161.  
  162. class _SIZE : public _PAIR
  163. {
  164. public:
  165.     _SIZE() {}
  166.     _SIZE( const _SIZE& rSize );
  167.     _SIZE( _SL_TYPE nWidth, _SL_TYPE nHeight ) : _PAIR( nWidth, nHeight ) {}
  168.     _SIZE( const _SIZE_2& rSize );
  169.  
  170.     _SL_TYPE     Width() const { return nA; }
  171.     _SL_TYPE     Height() const { return nB; }
  172.  
  173.     _SL_TYPE&    Width() { return nA; }
  174.     _SL_TYPE&    Height() { return nB; }
  175. };
  176.  
  177. class _RANGE : public _PAIR
  178. {
  179. public:
  180.     _RANGE() {}
  181.     _RANGE( const _RANGE& rRange );
  182.     _RANGE( _SL_TYPE nMin, _SL_TYPE nMax ) : _PAIR( nMin, nMax ) {}
  183.     _RANGE( const _RANGE_2& rRange );
  184.  
  185.     _SL_TYPE    Min() const { return nA; }
  186.     _SL_TYPE    Max() const { return nB; }
  187.     _SL_TYPE    Len() const { return nB - nA + 1; }
  188.  
  189.     _SL_TYPE&   Min() { return nA; }
  190.     _SL_TYPE&   Max() { return nB; }
  191.  
  192.     BOOL        IsInside( _SL_TYPE nIs ) const
  193.                     { return( (nA <= nIs) && (nIs <= nB ) ); }
  194.  
  195.     void        Justify();
  196. };
  197.  
  198. class _SELECTION : public _PAIR
  199. {
  200. public:
  201.     _SELECTION() {}
  202.     _SELECTION( const _SELECTION& rSelection );
  203.     _SELECTION( _SL_TYPE nPos ) : _PAIR( nPos, nPos ) {}
  204.     _SELECTION( _SL_TYPE nMin, _SL_TYPE nMax ) : _PAIR( nMin, nMax ) {}
  205.     _SELECTION( const _SELECTION_2& rSelection );
  206.  
  207.     _SL_TYPE    Min() const { return nA; }
  208.     _SL_TYPE    Max() const { return nB; }
  209.     _SL_TYPE    Len() const { return nB - nA; }
  210.  
  211.     _SL_TYPE&   Min() { return nA; }
  212.     _SL_TYPE&   Max() { return nB; }
  213.  
  214.     BOOL        IsInside( _SL_TYPE nIs ) const
  215.                     { return( (nA <= nIs) && (nIs < nB ) ); }
  216.     void        Justify();
  217.  
  218.     BOOL        operator !() const
  219.                     { return !Len(); }
  220. };
  221.  
  222. class _RECTANGLE
  223. {
  224. private:
  225.     _SL_TYPE       nLeft;
  226.     _SL_TYPE       nTop;
  227.     _SL_TYPE       nRight;
  228.     _SL_TYPE       nBottom;
  229.  
  230. public:
  231.     _RECTANGLE() { nLeft = nTop = nRight = nBottom = (_SL_TYPE) 0; }
  232.     _RECTANGLE( const _RECTANGLE& rRect );
  233.     _RECTANGLE( const _POINT& rLT, const _POINT& rRB )
  234.               : nLeft  ( rLT.X() ),
  235.                 nTop   ( rLT.Y() ),
  236.                 nRight ( rRB.X() ),
  237.                 nBottom( rRB.Y() ) {}
  238.     _RECTANGLE( _SL_TYPE nLeft, _SL_TYPE nTop,
  239.                 _SL_TYPE nRight, _SL_TYPE nBottom )
  240.               : nLeft  ( nLeft   ),
  241.                 nTop   ( nTop    ),
  242.                 nRight ( nRight  ),
  243.                 nBottom( nBottom ) {}
  244.     _RECTANGLE( const _POINT& rLT, const _SIZE& rSize )
  245.               : nLeft  ( rLT.X() ),
  246.                 nTop   ( rLT.Y() ),
  247.                 nRight ( nLeft  + rSize.Width()  - 1 ),
  248.                 nBottom( nTop   + rSize.Height() - 1 ) {}
  249.     _RECTANGLE( const _RECTANGLE_2& rRect );
  250.  
  251.     _SL_TYPE    Left() const { return nLeft;   }
  252.     _SL_TYPE    Right() const { return nRight;  }
  253.     _SL_TYPE    Top() const { return nTop;    }
  254.     _SL_TYPE    Bottom() const { return nBottom; }
  255.  
  256.     _SL_TYPE&   Left() { return nLeft;   }
  257.     _SL_TYPE&   Right() { return nRight;  }
  258.     _SL_TYPE&   Top() { return nTop;    }
  259.     _SL_TYPE&   Bottom() { return nBottom; }
  260.  
  261.     _POINT      TopLeft() const { return _POINT( (_SL_TYPE) nLeft, (_SL_TYPE) nTop ); }
  262.     _POINT      TopRight() const { return _POINT( (_SL_TYPE) nRight, (_SL_TYPE) nTop ); }
  263.     _POINT      TopCenter() const;
  264.     _POINT      BottomLeft() const { return _POINT( (_SL_TYPE) nLeft, (_SL_TYPE) nBottom ); }
  265.     _POINT      BottomRight() const { return _POINT( (_SL_TYPE) nRight, (_SL_TYPE) nBottom ); }
  266.     _POINT      BottomCenter() const;
  267.     _POINT      LeftCenter() const;
  268.     _POINT      RightCenter() const;
  269.     _POINT      Center() const;
  270.  
  271.     _POINT      ChangePos( const _POINT& rPoint );
  272.     _SIZE       ChangeSize( const _SIZE rSize );
  273.     _SIZE       GetSize() const { return _SIZE( nRight-nLeft+1, nBottom-nTop+1 ); }
  274.  
  275.     _RECTANGLE  GetUnion( const _RECTANGLE& rRect ) const;
  276.     _RECTANGLE  GetIntersection( const _RECTANGLE& rRect ) const;
  277.  
  278.     void        Justify();
  279.  
  280.     BOOL        IsInside( const _POINT& rPOINT ) const;
  281.     BOOL        IsInside( const _RECTANGLE& rRect ) const;
  282.     BOOL        IsOver( const _RECTANGLE& rRect ) const;
  283.  
  284.     BOOL        operator == ( const _RECTANGLE& rRect ) const;
  285.     BOOL        operator != ( const _RECTANGLE& rRect ) const;
  286.  
  287.     _RECTANGLE& operator = ( const _RECTANGLE& rRect );
  288. };
  289.  
  290. #undef _PAIR
  291. #undef _POINT
  292. #undef _SIZE
  293. #undef _RANGE
  294. #undef _SELECTION
  295. #undef _RECTANGLE
  296.  
  297. #undef _PAIR_2
  298. #undef _POINT_2
  299. #undef _SIZE_2
  300. #undef _RANGE_2
  301. #undef _SELECTION_2
  302. #undef _RECTANGLE_2
  303.  
  304. #undef _SL_TYPE
  305.  
  306. #ifndef _GEN_HXX
  307. #define _GEN_HXX
  308. #endif
  309.  
  310. #ifndef _GEN_HXX
  311. #define _GEN_HXX
  312.  
  313. #endif 
  314.  
  315.  
  316. #ifndef _FRACT_HXX
  317. #define _FRACT_HXX
  318.  
  319. #ifndef _TOOLS_H
  320. #endif
  321.  
  322. class Fraction
  323. {
  324. private:
  325.     short     nNumerator, nDenominator;
  326.  
  327. public:
  328.               Fraction() { nNumerator = 0; nDenominator = 1; };
  329.               Fraction( short nNum, short nDen=1 );
  330.               Fraction( double dVal );
  331.  
  332.     BOOL      IsValid() const { return nDenominator > 0? TRUE : FALSE; };
  333.  
  334.     short     GetNumerator() const { return nNumerator; }
  335.     short     GetDenominator() const { return nDenominator; }
  336.  
  337.     operator  short() const;
  338.     operator  double() const;
  339.     Fraction& operator=( const Fraction& rfrFrac );
  340.  
  341.     Fraction& operator+=( const Fraction& rfrFrac );
  342.     Fraction& operator-=( const Fraction& rfrFrac );
  343.     Fraction& operator*=( const Fraction& rfrFrac );
  344.     Fraction& operator/=( const Fraction& rfrFrac );
  345.  
  346.     friend Fraction operator+( const Fraction & aVal1, const Fraction & aVal2 );
  347.     friend Fraction operator-( const Fraction & aVal1, const Fraction & aVal2 );
  348.     friend Fraction operator*( const Fraction & aVal1, const Fraction & aVal2 );
  349.     friend Fraction operator/( const Fraction & aVal1, const Fraction & aVal2 );
  350.  
  351.     friend BOOL operator<( const Fraction & aVal1, const Fraction & aVal2 );
  352.     friend BOOL operator>( const Fraction & aVal1, const Fraction & aVal2 );
  353.     friend BOOL operator==( const Fraction & aVal1, const Fraction & aVal2 );
  354.     friend BOOL operator!=( const Fraction & aVal1, const Fraction & aVal2 );
  355.     friend BOOL operator<=( const Fraction & aVal1, const Fraction & aVal2 );
  356.     friend BOOL operator>=( const Fraction & aVal1, const Fraction & aVal2 );
  357. };
  358.  
  359. #endif 
  360.  
  361. #ifndef _STRING_HXX
  362. #define _STRING_HXX
  363.  
  364. #ifndef _TOOLS_H
  365. #endif
  366.  
  367. struct StringData
  368. {
  369.     char*     pStr;          
  370.     USHORT    nLen;          
  371.     USHORT    nRefCount;     
  372.     USHORT    nGapPos;       
  373.     USHORT    nGapSize;      
  374. };
  375.  
  376. #define STRING_NOTFOUND    ((USHORT)0xFFFF)
  377. #define STRING_MATCH       ((USHORT)0xFFFF)
  378. #define STRING_LEN         ((USHORT)0xFFFF)
  379. #define STRING_MAXLEN      ((USHORT)0xFFFE)
  380.  
  381. class String
  382. {
  383. private:
  384.     StringData*    pData;
  385.  
  386. public:
  387.                    String();
  388.                    String( const String& rStr );
  389.                    String( const String& rStr, USHORT nPos, USHORT nLen );
  390.                    String( const char* pCharStr );
  391.                    String( const char* pCharStr, USHORT nLen );
  392.                    String( char c );
  393.                    String( int n );
  394.                    String( unsigned int n );
  395.                    String( short n );
  396.                    String( USHORT n );
  397.                    String( long n );
  398.                    String( ULONG n );
  399.  
  400.                    ~String();
  401.  
  402.     operator       const char*() const;
  403.     operator       char() const;
  404.     operator       int() const;
  405.     operator       unsigned int() const;
  406.     operator       short() const;
  407.     operator       USHORT() const;
  408.     operator       long() const;
  409.     operator       ULONG() const;
  410.  
  411.     String&        operator =  ( const String& rStr );
  412.     String&        operator =  ( const char* pCharStr );
  413.  
  414.     String&        operator += ( const String& rStr );
  415.     String&        operator += ( const char* pCharStr );
  416.     String&        operator += ( char c );
  417.     String&        operator += ( int n );
  418.     String&        operator += ( unsigned int n );
  419.     String&        operator += ( short n );
  420.     String&        operator += ( USHORT n );
  421.     String&        operator += ( long n );
  422.     String&        operator += ( ULONG n );
  423.  
  424.     BOOL           operator !  () const;
  425.  
  426.     char           operator [] ( USHORT nIndex ) const;
  427.     char&          operator [] ( USHORT nIndex );
  428.  
  429.     USHORT         Len() const;
  430.  
  431.     String&        Insert( const String& rStr, USHORT nIndex = STRING_LEN );
  432.     String&        Insert( const String& rStr, USHORT nPos, USHORT nLen,
  433.                            USHORT nIndex = STRING_LEN );
  434.     String&        Insert( const char* pCharStr, USHORT nIndex = STRING_LEN );
  435.     String&        Insert( char c, USHORT nIndex = STRING_LEN );
  436.     String&        Insert( int n, USHORT nIndex = STRING_LEN );
  437.     String&        Insert( unsigned int n, USHORT nIndex = STRING_LEN );
  438.     String&        Insert( short n, USHORT nIndex = STRING_LEN );
  439.     String&        Insert( USHORT n, USHORT nIndex = STRING_LEN );
  440.     String&        Insert( long n, USHORT nIndex = STRING_LEN );
  441.     String&        Insert( ULONG n, USHORT nIndex = STRING_LEN );
  442.     String&        Replace( const String& rStr, USHORT nIndex = 0 );
  443.     String&        Erase( USHORT nIndex = 0, USHORT nCount = STRING_LEN );
  444.     String         Cut( USHORT nIndex = 0, USHORT nCount = STRING_LEN );
  445.     String         Copy( USHORT nIndex = 0, USHORT nCount = STRING_LEN ) const;
  446.  
  447.     String&        Fill( USHORT nCount, char cFillChar = ' ' );
  448.     String&        Expand( USHORT nCount, char cExpandChar = ' ' );
  449.  
  450.     String         Upper() const;
  451.     String         Lower() const;
  452.  
  453.     String&        ToUpper();
  454.     String&        ToLower();
  455.  
  456.     String&        SpaceToZero();
  457.     String&        ZeroToSpace();
  458.  
  459.     USHORT         Match( const String& rStr ) const;
  460.     USHORT         Match( const char* pCharStr ) const;
  461.  
  462.     USHORT         Search( const String& rStr, USHORT nIndex = 0 ) const;
  463.     USHORT         Search( const char* pCharStr, USHORT nIndex = 0 ) const;
  464.  
  465.     BOOL           IsAlpha() const;
  466.     BOOL           IsNumeric() const;
  467.     BOOL           IsAlphaNumeric() const;
  468.     BOOL           IsUpper() const;
  469.     BOOL           IsLower() const;
  470.  
  471.     char*          AllocStrBuf( USHORT nLen );
  472.     const char*    StrGet() const;
  473.  
  474.     friend String  operator +  ( const String& rStr1,  const String& rStr2  );
  475.     friend String  operator +  ( const String& rStr,   const char* pCharStr );
  476.     friend String  operator +  ( const char* pCharStr, const String& rStr   );
  477.  
  478.     friend BOOL    operator == ( const String& rStr1,  const String& rStr2  );
  479.     friend BOOL    operator == ( const String& rStr,   const char* pCharStr );
  480.     friend BOOL    operator == ( const char* pCharStr, const String& rStr   );
  481.     friend BOOL    operator != ( const String& rStr1,  const String& rStr2  );
  482.     friend BOOL    operator != ( const String& rStr,   const char* pCharStr );
  483.     friend BOOL    operator != ( const char* pCharStr, const String& rStr   );
  484.     friend BOOL    operator <  ( const String& rStr1,  const String& rStr2  );
  485.     friend BOOL    operator <  ( const String& rStr,   const char* pCharStr );
  486.     friend BOOL    operator <  ( const char* pCharStr, const String& rStr   );
  487.     friend BOOL    operator >  ( const String& rStr1,  const String& rStr2  );
  488.     friend BOOL    operator >  ( const String& rStr,   const char* pCharStr );
  489.     friend BOOL    operator >  ( const char* pCharStr, const String& rStr   );
  490.     friend BOOL    operator <= ( const String& rStr1,  const String& rStr2  );
  491.     friend BOOL    operator <= ( const String& rStr,   const char* pCharStr );
  492.     friend BOOL    operator <= ( const char* pCharStr, const String& rStr   );
  493.     friend BOOL    operator >= ( const String& rStr1,  const String& rStr2  );
  494.     friend BOOL    operator >= ( const String& rStr,   const char* pCharStr );
  495.     friend BOOL    operator >= ( const char* pCharStr, const String& rStr   );
  496.  
  497.     String         operator() ( int n1, int n2 ) const
  498.                         { return Copy( n1, n2 ); }
  499.     char&          operator() ( int n )
  500.                         { return String::operator[](n); }
  501.     unsigned int   length() const
  502.                         { return Len(); }
  503.  
  504.     int            match( const String& r ) const
  505.                         { USHORT n;
  506.                           if ( (n = Match( r )) == STRING_MATCH )
  507.                               return -1;
  508.                           else
  509.                               return (int)n;
  510.                         }
  511.     int            match( const char* p ) const
  512.                         { USHORT n;
  513.                           if ( (n = Match( p )) == STRING_MATCH )
  514.                               return -1;
  515.                           else
  516.                               return (int)n;
  517.                         }
  518.  
  519.     int            index( const String& r, unsigned int pos = 0 ) const
  520.                         { USHORT n;
  521.                           if ( (n = Search( r, pos )) == STRING_NOTFOUND )
  522.                               return -1;
  523.                           else
  524.                               return (int)n;
  525.                         }
  526.     int            index( const char* p, unsigned int pos = 0 ) const
  527.                         { USHORT n;
  528.                           if ( (n = Search( p, pos )) == STRING_NOTFOUND )
  529.                               return -1;
  530.                           else
  531.                               return (int)n;
  532.                         }
  533.  
  534.     String upper() const
  535.                         { return Upper(); }
  536.     String lower() const
  537.                         { return Lower(); }
  538. };
  539.  
  540. #endif 
  541.  
  542. #ifndef _MTF_HXX
  543. #define _MTF_HXX
  544.  
  545. #ifndef _TOOLS_H
  546. #endif
  547.  
  548. #ifndef _LINK_HXX
  549. #endif
  550.  
  551. #ifndef _STRING_HXX
  552. #endif
  553.  
  554. class MetaFile;
  555. class ActionList;
  556. class LabelList;
  557.  
  558. class MetaAction
  559. {
  560. private:
  561.     USHORT         nRefCount;     
  562.     USHORT         nActionType;   
  563.  
  564. public:
  565.                    MetaAction();
  566.                    MetaAction( USHORT nType );
  567.     virtual        ~MetaAction();
  568.  
  569.     virtual void   Execute( void* );
  570.  
  571.     USHORT         GetType() const { return nActionType; }
  572.  
  573.     void           Duplicate()  { nRefCount++; }
  574.     void           Delete()     { nRefCount--; if ( !nRefCount ) delete this; }
  575. };
  576.  
  577. class MetaFile
  578. {
  579. private:
  580.     Link                aHookHdlLink;       
  581.     void*               pRecordObject;      
  582.     ActionList*         pActionList;        
  583.     LabelList*          pLabelList;         
  584.     BOOL                bPause;             
  585.     BOOL                bRecord;            
  586.  
  587. protected:
  588.     virtual void        Linker( void*, BOOL );
  589.     virtual long        Hook();
  590.  
  591. public:
  592.                         MetaFile();
  593.                         MetaFile( const MetaFile& rMtf );
  594.     virtual             ~MetaFile();
  595.  
  596.     BOOL                AddAction( MetaAction* pAction );
  597.  
  598.     BOOL                Clear();
  599.  
  600.     BOOL                Record( void* pObj );
  601.     BOOL                Pause( BOOL bPaused );
  602.     BOOL                Stop();
  603.     BOOL                Play( void* pObj );
  604.     BOOL                Play( void* pObj, const String& rToLabal );
  605.     BOOL                Play( MetaFile& rMtf );
  606.     BOOL                Play( MetaFile& rMtf, const String& rToLabal );
  607.  
  608.     BOOL                IsRecord() const { return bRecord; }
  609.     BOOL                IsPause() const  { return bPause;  }
  610.  
  611.     BOOL                WindStart();
  612.     BOOL                WindEnd();
  613.     BOOL                Wind( const String& rToLabel );
  614.     BOOL                WindPrev();
  615.     BOOL                WindNext();
  616.  
  617.     BOOL                SetLabel( const String& rLabel );
  618.     String              GetLabel( ULONG nLabel ) const;
  619.     ULONG               GetLabelCount() const;
  620.     String              GetCurLabel() const;
  621.  
  622.     ULONG               GetActionCount() const;
  623.     ULONG               GetLabelActionCount( const String& rLabel ) const;
  624.     const MetaAction*   GetCurAction() const;
  625.  
  626.     Link                ChangeHookHdl( const Link& rLink );
  627.     Link                GetHookHdl() const;
  628.  
  629.     MetaFile&           operator=( const MetaFile& rMtf );
  630. };
  631.  
  632. #endif 
  633.  
  634. #ifndef _CONTNR_HXX
  635. #define _CONTNR_HXX
  636.  
  637. #ifndef _TOOLS_H
  638. #endif
  639.  
  640. class CBlock;
  641.  
  642. #define CONTAINER_APPEND           ((ULONG)0xFFFFFFFF)
  643. #define CONTAINER_ENTRY_NOTFOUND   ((ULONG)0xFFFFFFFF)
  644.  
  645. class Container
  646. {
  647. private:
  648.     CBlock*        pFirstBlock;
  649.     CBlock*        pLastBlock;
  650.     CBlock*        pCurBlock;
  651.     USHORT         nCurIndex;
  652.  
  653.     USHORT         nBlockSize;
  654.     USHORT         nInitSize;
  655.     USHORT         nReSize;
  656.  
  657.     ULONG          nCount;
  658.  
  659. protected:
  660.  
  661. public:
  662.                    Container( USHORT nBlockSize,
  663.                               USHORT nInitSize,
  664.                               USHORT nReSize );
  665.                    Container( ULONG nSize );
  666.                    Container( const Container& rContainer );
  667.     virtual        ~Container();
  668.  
  669.     void           Insert( void* p );
  670.     void           Insert( void* p, ULONG nIndex );
  671.     void           Insert( void* pNew, void* pOld );
  672.  
  673.     void*          Remove();
  674.     void*          Remove( ULONG nIndex );
  675.     void*          Remove( void* p );
  676.  
  677.     void*          Replace( void* p );
  678.     void*          Replace( void* p, ULONG nIndex );
  679.     void*          Replace( void* pNew, void* pOld );
  680.  
  681.     ULONG          ChangeSize( ULONG nNewSize );
  682.     ULONG          GetSize() const { return nCount; }
  683.  
  684.     ULONG          Count() const { return nCount; }
  685.     void           Clear();
  686.  
  687.     void*          GetCurObject() const;
  688.     ULONG          GetCurPos() const;
  689.     void*          GetObject( ULONG nIndex ) const;
  690.     ULONG          GetPos( void* p ) const;
  691.  
  692.     void*          Seek( ULONG nIndex );
  693.     void*          Seek( void* p );
  694.     void*          First();
  695.     void*          Last();
  696.     void*          Next();
  697.     void*          Prev();
  698.  
  699.     void           operator =( const Container& rContainer );
  700.     BOOL           operator ==( const Container& rContainer ) const;
  701.     BOOL           operator !=( const Container& rContainer ) const;
  702. };
  703.  
  704. #endif 
  705.  
  706.  
  707. #ifndef _LIST_HXX
  708. #define _LIST_HXX
  709.  
  710. #ifndef _TOOLS_H
  711. #endif
  712.  
  713. #ifndef _CONTNR_HXX
  714. #endif
  715.  
  716. #define LIST_APPEND           CONTAINER_APPEND
  717. #define LIST_ENTRY_NOTFOUND   CONTAINER_ENTRY_NOTFOUND
  718.  
  719. class List : private Container
  720. {
  721. public:
  722.               List( USHORT nInitSize = 16, USHORT nReSize = 16 );
  723.               List( USHORT nBlockSize, USHORT nInitSize,
  724.                     USHORT nReSize );
  725.               List( const List& rList );
  726.     virtual   ~List();
  727.  
  728.     void      Insert( void* p )
  729.                   { Container::Insert( p ); }
  730.     void      Insert( void* p, ULONG nIndex )
  731.                   { Container::Insert( p, nIndex ); }
  732.     void      Insert( void* pNew, void* pOld )
  733.                   { Container::Insert( pNew, pOld ); }
  734.  
  735.     void*     Remove()
  736.                   { return Container::Remove(); }
  737.     void*     Remove( ULONG nIndex )
  738.                   { return Container::Remove( nIndex ); }
  739.     void*     Remove( void* p )
  740.                   { return Container::Remove( p ); }
  741.  
  742.     void*     Replace( void* p )
  743.                   { return Container::Replace( p ); }
  744.     void*     Replace( void* p, ULONG nIndex )
  745.                   { return Container::Replace( p, nIndex ); }
  746.     void*     Replace( void* pNew, void* pOld )
  747.                   { return Container::Replace( pNew, pOld ); }
  748.  
  749.     void      Clear() { Container::Clear(); }
  750.     ULONG     Count() const { return Container::Count(); }
  751.  
  752.     void*     GetCurObject() const
  753.                   { return Container::GetCurObject(); }
  754.     ULONG     GetCurPos() const
  755.                   { return Container::GetCurPos(); }
  756.     void*     GetObject( ULONG nIndex ) const
  757.                   { return Container::GetObject( nIndex ); }
  758.     ULONG     GetPos( void* p ) const
  759.                   { return Container::GetPos( p ); }
  760.  
  761.     void*     Seek( ULONG nIndex ) { return Container::Seek( nIndex ); }
  762.     void*     Seek( void* p )      { return Container::Seek( p );      }
  763.     void*     First()              { return Container::First();        }
  764.     void*     Last()               { return Container::Last();         }
  765.     void*     Next()               { return Container::Next();         }
  766.     void*     Prev()               { return Container::Prev();         }
  767.  
  768.     List&     operator =( const List& rList )
  769.                   { Container::operator =( rList ); return *this; }
  770.  
  771.     BOOL      operator ==( const List& rList ) const
  772.                   { return Container::operator ==( rList ); }
  773.     BOOL      operator !=( const List& rList ) const
  774.                   { return Container::operator !=( rList ); }
  775. };
  776.  
  777. #define DECLARE_LIST( ClassName, Type )                                   \
  778. class ClassName : public List                                             \
  779. {                                                                         \
  780. public:                                                                   \
  781.          ClassName( USHORT nInitSize = 16, USHORT nReSize = 16 ) :        \
  782.              List( nInitSize, nReSize ) {}                                \
  783.          ClassName( USHORT nBlockSize, USHORT nInitSize,                  \
  784.                     USHORT nReSize ) :                                    \
  785.              List( nBlockSize, nInitSize, nReSize ) {}                    \
  786.                                                                           \
  787.     void Insert( Type p, ULONG nIndex )                                   \
  788.              { List::Insert( (void*)p, nIndex ); }                        \
  789.     void Insert( Type p )                                                 \
  790.              { List::Insert( (void*)p ); }                                \
  791.     void Insert( Type pNew, Type pOld )                                   \
  792.              { List::Insert( (void*)pNew, (void*)pOld ); }                \
  793.     Type Remove()                                                         \
  794.              { return (Type)List::Remove(); }                             \
  795.     Type Remove( ULONG nIndex )                                           \
  796.              { return (Type)List::Remove( nIndex ); }                     \
  797.     Type Remove( Type p )                                                 \
  798.              { return (Type)List::Remove( (void*)p ); }                   \
  799.     Type Replace( Type p )                                                \
  800.              { return (Type)List::Replace( (void*)p ); }                  \
  801.     Type Replace( Type p, ULONG nIndex )                                  \
  802.              { return (Type)List::Replace( (void*)p, nIndex ); }          \
  803.     Type Replace( Type pNew, Type pOld )                                  \
  804.              { return (Type)List::Replace( (void*)pNew, (void*)pOld ); }  \
  805.                                                                           \
  806.     Type GetCurObject() const                                             \
  807.              { return (Type)List::GetCurObject(); }                       \
  808.     Type GetObject( ULONG nIndex ) const                                  \
  809.              { return (Type)List::GetObject( nIndex ); }                  \
  810.     ULONG GetPos( Type p ) const                                          \
  811.              { return List::GetPos( (void*)p ); }                         \
  812.                                                                           \
  813.     Type Seek( ULONG nIndex ) { return (Type)List::Seek( nIndex ); }      \
  814.     Type Seek( void* p )      { return (Type)List::Seek( p );      }      \
  815.     Type First()              { return (Type)List::First();        }      \
  816.     Type Last()               { return (Type)List::Last();         }      \
  817.     Type Next()               { return (Type)List::Next();         }      \
  818.     Type Prev()               { return (Type)List::Prev();         }      \
  819. };
  820.  
  821. #endif 
  822. #endif
  823.