/opencascade-6.5.1/ros/src/WNT/W95_Allocator.cxx

https://github.com/jehc/MondocosmOS · C++ · 1202 lines · 751 code · 359 blank · 92 comment · 87 complexity · 59603e21516dab8e2e87da362dab617b MD5 · raw file 

    

  1. ////////////////////////////////////////////////////////////////////////////////
    2. 

  2. // W95_Allocator                                                              //
    3. 

  3. //  Provides memory management and drawing operations for Windows 95.         //
    4. 

  4. //   World transformations and styled lines are managed by EHDC stuff.        //
    5. 

  5. //                                                                            //
    6. 

  6. // History: FEB-98 - creation (EUG)                                           //
    7. 

  7. //          MAR-98 - modification (DCB)                                       //
    8. 

  8. //                                                                            //
    9. 

  9. // Notes:   bitmap rotation code was created by MPO                           //
    10. 

  10. ////////////////////////////////////////////////////////////////////////////////
    11. 

  11. #include "W95_Allocator.hxx"
    12. 

  12. 

  13. #include <math.h>
    14. 

  14. #include <limits>
    15. 

  15. 

  16. #define SGN( x )  (   ( x ) > 0 ? 1 : (  ( x ) < 0 ? -1 : 0 )   )
    17. 

  17. #define ALLOCATOR (   ( PW95_Allocator )myAllocator             )
    18. 

  18. 

  19. #define MIN4( a, b, c, d ) min(   min(  ( a ), ( b )  ), min(  ( c ), ( d )  )   )
    20. 

  20. #define MAX4( a, b, c, d ) max(   max(                                       \
    21. 

  21.                                    (  ( a ) == INT_MAX ? INT_MIN : ( a )  ), \
    22. 

  22.                                    (  ( b ) == INT_MAX ? INT_MIN : ( b )  )  \
    23. 

  23.                                   ),                                         \
    24. 

  24.                                   max(                                       \
    25. 

  25.                                    (  ( c ) == INT_MAX ? INT_MIN : ( c )  ), \
    26. 

  26.                                    (  ( d ) == INT_MAX ? INT_MIN : ( d )  )  \
    27. 

  27.                                   )                                          \
    28. 

  28.                            )
    29. 

  29. 

  30. static void WINAPI _InitXform      ( PXFORM, double, int, int );
    31. 

  31. static VOID CALLBACK _LineDDAProc  ( int, int, LPARAM         );	
    32. 

  32. 

  33. W95_Allocator :: W95_Allocator ( int anID, PW32_Allocator prev ) :
    34. 

  34.                   W32_Allocator ( anID, prev ) {
    35. 

  35. 

  36.  myLinePenWidth      = 0;
    37. 

  37.  myLineBrush.lbStyle = BS_SOLID;
    38. 

  38.  myLineBrush.lbColor = RGB( 0, 0, 0 );
    39. 

  39.  myLineBrush.lbHatch = 0;
    40. 

  40.  myLineStyleCount    = 0;
    41. 

  41.  myLineStyles        = NULL;
    42. 

  42.                         
    43. 

  43.  myPolyBrush.lbStyle = BS_NULL;
    44. 

  44. 

  45.  myTextColor         = RGB( 0, 0, 0 );
    46. 

  46. 

  47.  myMarkerBrush       = myPolyBrush;
    48. 

  48.  myMarkerWidth       = 0;
    49. 

  49.  myFlags            |= W32F_WIN95;
    50. 

  50.                                                       
    51. 

  51. }  // end constructor
    52. 

  52. 

  53. W95_Allocator :: ~W95_Allocator () {
    54. 

  54. 

  55.  if ( myLineStyles != NULL ) HeapFree (
    56. 

  56.                               GetProcessHeap (), 0, ( LPVOID )myLineStyles
    57. 

  57.                              );
    58. 

  58. 

  59. }  // end destructor
    60. 

  60. 

  61. void W95_Allocator :: Play ( HDC hdc, PSIZE szClient ) {
    62. 

  62. 

  63.  if (  !( myFlags & W32F_EMPTY )  ) {
    64. 

  64. 

  65.   myHDC.SetDC ( hdc, szClient );
    66. 

  66.   myHDC.ResetURect ();
    67. 

  67.   myHDC.SelectEPen (
    68. 

  68.          myLinePenWidth, &myLineBrush,
    69. 

  69.          myLineStyleCount, myLineStyles
    70. 

  70.         );
    71. 

  71.   myHDC.SelectEBrush ( &myPolyBrush, NULL );
    72. 

  72.   myHDC.SetTextAttrib (
    73. 

  73.          myTextColor, myTextFont, myTextSlant,
    74. 

  74.          myTextHScale, myTextVScale
    75. 

  75.         );
    76. 

  76.   myHDC.SetPolyFillMode ( myFillMode );
    77. 

  77. 

  78.   Xform ();
    79. 

  79. 

  80.   for ( PW32_Block aBlock = myStart; aBlock != NULL; aBlock = aBlock -> next )
    81. 

  81. 

  82.    for ( int i = 0; i < aBlock -> free; i += aBlock -> data[ i ] )
    83. 

  83. 	    
    84. 

  84.     if ( aBlock -> data[ i + 1 ] != __W32_DATA ) {                                         
    85. 

  85. 

  86.      W32_Note* pNote = ( W32_Note* )&( aBlock -> data[ i + 1 ] );
    87. 

  87.      pNote -> Play ();
    88. 

  88. 

  89.     }  // end if
    90. 

  90. 

  91.  }  // end if
    92. 

  92. 

  93. }  // end W95_Allocator :: Play
    94. 

  94. 

  95. void W95_Allocator :: URect ( LPRECT lpRect ) {
    96. 

  96. 

  97.  myHDC.GetURect ( lpRect );
    98. 

  98. 

  99. }  // end W95_Allocator :: URect
    100. 

  100. 

  101. void W95_Allocator :: Xform ( void ) {
    102. 

  102. 

  103.  if ( myAngle  != 0.0 || myPivot.x != 0 || myPivot.y != 0 ||
    104. 

  104.       myMove.x != 0   || myMove.y  != 0 ||
    105. 

  105.       myScaleX != 1.0 || myScaleY  != 1.0
    106. 

  106.  ) {
    107. 

  107. 

  108.   XFORM  xf;
    109. 

  109.   double sinVal, cosVal;
    110. 

  110. 

  111.   sinVal = sin ( myAngle );
    112. 

  112.   cosVal = cos ( myAngle );
    113. 

  113. 

  114.   xf.eM11 =                1.0F; xf.eM12 =                0.0F;
    115. 

  115.   xf.eM21 =                0.0F; xf.eM22 =                1.0F;
    116. 

  116.   xf.eDx  = ( FLOAT )-myPivot.x; xf.eDy  = ( FLOAT )-myPivot.y;
    117. 

  117.   myHDC.SetWorldTransform ( &xf );
    118. 

  118. 

  119.   xf.eM11 = FLOAT (  cosVal * myScaleX ); xf.eM12 = FLOAT ( sinVal * myScaleX );
    120. 

  120.   xf.eM21 = FLOAT ( -sinVal * myScaleY ); xf.eM22 = FLOAT ( cosVal * myScaleY );
    121. 

  121.   xf.eDx  =                         0.0F; xf.eDy  =                        0.0F;
    122. 

  122.   myHDC.ModifyWorldTransform ( &xf, MWT_RIGHTMULTIPLY );
    123. 

  123. 

  124.   xf.eM11 =                           1.0F; xf.eM12 =                           0.0F;
    125. 

  125.   xf.eM21 =                           0.0F; xf.eM22 =                           1.0F;
    126. 

  126.   xf.eDx  = FLOAT ( myPivot.x + myMove.x ); xf.eDy  = FLOAT ( myPivot.y + myMove.y );
    127. 

  127.   myHDC.ModifyWorldTransform ( &xf, MWT_RIGHTMULTIPLY );
    128. 

  128. 

  129.   myFlags |= W32F_XFORM;
    130. 

  130. 

  131.  } else {
    132. 

  132.  
    133. 

  133.   myHDC.ModifyWorldTransform ( NULL, MWT_IDENTITY );
    134. 

  134.   myFlags &= ~W32F_XFORM;
    135. 

  135. 

  136.  }  // end else
    137. 

  137. 

  138. }  // end W95_Allocator :: Xform
    139. 

  139. 

  140. void W95_Allocator :: Point ( int x, int y ) {
    141. 

  141. 

  142.  new ( this ) W32_PointNote ( x, y );
    143. 

  143. 

  144. }  // end W95_Allocator :: Point
    145. 

  145. 

  146. void W95_Allocator :: MarkerPoint ( int x, int y ) {
    147. 

  147. 

  148.  new ( this ) W32_MarkerPointNote ( x, y );
    149. 

  149. 

  150. }  // end W95_Allocator :: MarkerPoint
    151. 

  151. 

  152. void W95_Allocator :: Line ( int x, int y, int x1, int y1 ) {
    153. 

  153. 

  154.  new ( this ) W32_LineNote ( x, y, x1, y1 );
    155. 

  155. 

  156. }  // end W95_Allocator :: Line
    157. 

  157. 

  158. void W95_Allocator :: PolyEllipse ( int xc, int yc, int xr, int yr ) {
    159. 

  159. 

  160.  new ( this ) W32_PolyEllipseNote ( xc, yc, xr, yr );
    161. 

  161. 

  162. }  // end W95_Allocator :: PolyEllipse
    163. 

  163. 

  164. void W95_Allocator :: Ellipse ( int xc, int yc, int xr, int yr ) {
    165. 

  165. 

  166.  new ( this ) W32_EllipseNote ( xc, yc, xr, yr );
    167. 

  167. 

  168. }  // end W95_Allocator :: Ellipse
    169. 

  169. 

  170. void W95_Allocator :: Arc (
    171. 

  171.                        int xc, int yc, int xr, int yr,
    172. 

  172.                        double sa, double oa
    173. 

  173.                       ) {
    174. 

  174.                       
    175. 

  175.  new ( this ) W32_ArcNote ( xc, yc, xr, yr, sa, oa );                      
    176. 

  176.                       
    177. 

  177. }  // end W95_Allocator :: Arc
    178. 

  178. 

  179. void W95_Allocator :: PolyChord (
    180. 

  180.                        int xc, int yc, int xr, int yr,
    181. 

  181.                        double sa, double oa
    182. 

  182.                       ) {
    183. 

  183.                       
    184. 

  184.  new ( this ) W32_PolyChordNote ( xc, yc, xr, yr, sa, oa );
    185. 

  185.                       
    186. 

  186. }  // end W95_Allocator :: PolyChord
    187. 

  187. 

  188. void W95_Allocator :: Chord (
    189. 

  189.                        int xc, int yc, int xr, int yr,
    190. 

  190.                        double sa, double oa
    191. 

  191.                       ) {
    192. 

  192.                       
    193. 

  193.  new ( this ) W32_PolyChordNote ( xc, yc, xr, yr, sa, oa );
    194. 

  194.                       
    195. 

  195. }  // end W95_Allocator :: Chord
    196. 

  196. 

  197. void W95_Allocator :: PolySector (
    198. 

  198.                        int xc, int yc, int xr, int yr,
    199. 

  199.                        double sa, double oa
    200. 

  200.                       ) {
    201. 

  201.                       
    202. 

  202.  new ( this ) W32_PolySectorNote ( xc, yc, xr, yr, sa, oa );
    203. 

  203.                       
    204. 

  204. }  // end W95_Allocator :: PolySector
    205. 

  205. 

  206. void W95_Allocator :: Sector (
    207. 

  207.                        int xc, int yc, int xr, int yr,
    208. 

  208.                        double sa, double oa
    209. 

  209.                       ) {
    210. 

  210.                       
    211. 

  211.  new ( this ) W32_SectorNote ( xc, yc, xr, yr, sa, oa );
    212. 

  212.                       
    213. 

  213. }  // end W95_Allocator :: Sector
    214. 

  214. 

  215. void W95_Allocator :: PolyMarker ( int aMaxPoints ) {
    216. 

  216. 

  217.  new ( this ) W32_PolyMarkerNote ( aMaxPoints );
    218. 

  218. 

  219. }  // end W95_Allocator :: PolyMarker
    220. 

  220. 

  221. void W95_Allocator :: PolyMarker1 (
    222. 

  222.                        int aMaxPoints, GetPointFunc fn,
    223. 

  223.                        int aStartPoint, void* fParam
    224. 

  224.                       ) {
    225. 

  225.                       
    226. 

  226.  new ( this ) W32_PolyMarker1Note (
    227. 

  227.                aMaxPoints, fn, aStartPoint, fParam
    228. 

  228.               );                      
    229. 

  229.                       
    230. 

  230. }  // end W95_Allocator :: PolyMarker1
    231. 

  231. 

  232. void W95_Allocator :: PolyMarker2 (
    233. 

  233.                        int aMaxPoints, GetPointFunc fn,
    234. 

  234.                        int aStartPoint, void* fParam
    235. 

  235.                       ) {
    236. 

  236.                       
    237. 

  237.  new ( this ) W32_PolyMarker2Note (
    238. 

  238.                aMaxPoints, fn, aStartPoint, fParam
    239. 

  239.               );                      
    240. 

  240.                       
    241. 

  241. }  // end W95_Allocator :: PolyMarker1
    242. 

  242. 

  243. W32_Note* W95_Allocator :: Polygon ( int aMaxPoints ) {
    244. 

  244. 

  245.  return new ( this ) W32_PolygonNote ( aMaxPoints );
    246. 

  246. 

  247. }  // end W95_Allocator :: Polygon
    248. 

  248. 

  249. W32_Note* W95_Allocator :: Polyline ( int aMaxPoints ) {
    250. 

  250. 

  251.  return new ( this ) W32_PolylineNote ( aMaxPoints );
    252. 

  252. 

  253. }  // end W95_Allocator :: Polyline
    254. 

  254. 

  255. void W95_Allocator :: Image (
    256. 

  256.                        int x, int y, PW32_Bitmap pBmp, double aScale
    257. 

  257.                       ) {
    258. 

  258. 

  259.  new ( this ) W32_ImageNote ( x, y, pBmp, aScale );
    260. 

  260. 

  261. }  // end W95_Allocator :: Image
    262. 

  262. 

  263. void W95_Allocator :: Text (
    264. 

  264.                        int x, int y, double angle, void* text,
    265. 

  265.                        BOOL fWide, BOOL fOutlined
    266. 

  266.                       ) {
    267. 

  267. 

  268.  new ( this ) W32_TextNote ( x, y, angle, text, fWide, fOutlined );
    269. 

  269. 

  270. }  // end W95_Allocator :: Text
    271. 

  271. 

  272. void W95_Allocator :: Polytext (
    273. 

  273.                        int x, int y, double angle, double margin,
    274. 

  274.                        void* text, BOOL fWide, BOOL fOutlined
    275. 

  275.                       ) {
    276. 

  276.                       
    277. 

  277.  new ( this ) W32_PolyTextNote ( x, y, angle, margin, text, fWide, fOutlined );                      
    278. 

  278.                       
    279. 

  279. }  // end W95_Allocator :: Polytext
    280. 

  280. 

  281. void W95_Allocator :: BeginMarker (
    282. 

  282.                        int x, int y, int w, int h, double angle
    283. 

  283.                       ) {
    284. 

  284.                       
    285. 

  285.  new ( this ) W32_BeginMarkerNote ( x, y, w, h, angle );                      
    286. 

  286.                       
    287. 

  287. }  // end W95_Allocator :: BeginMarker
    288. 

  288. 

  289. void W95_Allocator :: EndMarker ( void ) {
    290. 

  290. 

  291.  new ( this ) W32_EndMarkerNote ();
    292. 

  292. 

  293. }  // end W95_Allocator :: EndMarker
    294. 

  294. 

  295. void W95_Allocator :: LineAttrib (
    296. 

  296.                        DWORD width, PLOGBRUSH plb,
    297. 

  297.                        DWORD nStyles, PDWORD pdwStyle
    298. 

  298.                       ) {
    299. 

  299.                       
    300. 

  300.  new ( this ) W32_LineAttribNote ( width, plb, nStyles, pdwStyle );
    301. 

  301.                       
    302. 

  302. }  // end W95_Allocator :: LineAttrib
    303. 

  303. 

  304. void W95_Allocator :: PolyAttrib (
    305. 

  305.                        PLOGBRUSH plb, BOOL fDrawEdge, int aFillMode
    306. 

  306.                       ) {
    307. 

  307. 

  308.  new ( this ) W32_PolyAttribNote ( plb, fDrawEdge, aFillMode );
    309. 

  309. 

  310. }  // end W95_Allocator :: PolyAttrib
    311. 

  311. 

  312. void W95_Allocator :: TextAttrib (
    313. 

  313.                        HFONT hFont, COLORREF color, double slant,
    314. 

  314.                        double hScale, double vScale,
    315. 

  315.                        BOOL fUnderlined, BOOL fFree, BOOL fIndex
    316. 

  316.                       ) {
    317. 

  317.                       
    318. 

  318.  if ( myFlags & W32F_START )
    319. 

  319. 

  320.   new ( this ) W32_TextAttribNote (
    321. 

  321.                 hFont, color, slant, hScale, vScale,
    322. 

  322.                 fUnderlined, fFree, fIndex
    323. 

  323.                );
    324. 

  324. 

  325.  else {
    326. 

  326.  
    327. 

  327.   if ( myFlags & W32F_DFONT && !fIndex ) {
    328. 

  328.  
    329. 

  329.    DeleteFont( myTextFont );
    330. 

  330.    myFlags &= ~W32F_DFONT;
    331. 

  331.  
    332. 

  332.   }  // end if
    333. 

  333. 

  334.   myTextColor   = color;
    335. 

  335.   myTextFont    = hFont;
    336. 

  336.   myTextSlant   = slant;
    337. 

  337.   myTextHScale  = vScale;
    338. 

  338.   myTextVScale  = hScale;
    339. 

  339.   myFlags      |= ( fUnderlined ? W32F_TULIN : 0 );
    340. 

  340.   
    341. 

  341.  }  // end else
    342. 

  342.                       
    343. 

  343. }  // end W95_Allocator :: TextAttrib
    344. 

  344. 

  345. void W95_Allocator :: MarkerAttrib (
    346. 

  346.                        COLORREF color, DWORD dwWidth, BOOL fFill
    347. 

  347.                       ) {
    348. 

  348.                       
    349. 

  349.  new ( this ) W32_MarkerAttribNote ( color, dwWidth, fFill );                      
    350. 

  350.                       
    351. 

  351. }  // end W95_Allocator :: MarkerAttrib
    352. 

  352. 

  353. void W95_Allocator :: FunCall (
    354. 

  354.                        W32_FCall fCall, int sz, PW32_FCALLPARAM param
    355. 

  355.                       ) {
    356. 

  356. 

  357.  new ( this ) W32_FCallNote ( fCall, sz, param );
    358. 

  358. 

  359. }  // end W95_Allocator :: FunCall
    360. 

  360. 

  361. int W95_Allocator :: TextSize ( HDC hdc, char* str, PSIZE psz )
    362. 

  362. {
    363. 

  363.   ABC        abcf;
    364. 

  364.   GetTextExtentPoint32A ( hdc, str, lstrlenA ( str ), psz );
    365. 

  365.   GetCharABCWidthsA     ( hdc, str[ 0 ], str[ 0 ], &abcf  );
    366. 

  366.   psz->cx    = LONG ( psz->cx   * myTextHScale );
    367. 

  367.   psz->cy    = LONG ( psz->cy   * myTextVScale );
    368. 

  368.   abcf.abcA  = UINT ( abcf.abcA * myTextHScale );
    369. 

  369.   return abcf.abcA;
    370. 

  370. }  // end W95_Allocator :: TextSize
    371. 

  371.   
    372. 

  372. int W95_Allocator :: TextSize ( HDC hdc, wchar_t* str, PSIZE psz )
    373. 

  373. {
    374. 

  374.   ABC        abcf;
    375. 

  375.   GetTextExtentPoint32W ( hdc, str, lstrlenW ( str ), psz );
    376. 

  376.   GetCharABCWidthsW     ( hdc, str[ 0 ], str[ 0 ], &abcf  );
    377. 

  377.   psz->cx    = LONG ( psz->cx   * myTextHScale );
    378. 

  378.   psz->cy    = LONG ( psz->cy   * myTextVScale );
    379. 

  379.   abcf.abcA  = UINT ( abcf.abcA * myTextHScale );
    380. 

  380.   return abcf.abcA;
    381. 

  381. }  // end W95_Allocator :: TextSize
    382. 

  382. ////////////////////////////////////////////////////////////////////////////////
    383. 

  383. // W 3 2 _ P o i n t N o t e                                                  //
    384. 

  384. ////////////////////////////////////////////////////////////////////////////////
    385. 

  385. W32_PointNote :: W32_PointNote ( int x, int y ) {
    386. 

  386. 

  387.  myX = x;
    388. 

  388.  myY = y;
    389. 

  389. 

  390. }  // end constructor
    391. 

  391. 

  392. void W32_PointNote :: Play ( BOOL fDummy ) {
    393. 

  393. 

  394.  ALLOCATOR -> myHDC.SetPixel (  myX, myY, ALLOCATOR -> myPointColor  );
    395. 

  395. 

  396. }  // end W32_PointNote :: Play
    397. 

  397. ////////////////////////////////////////////////////////////////////////////////
    398. 

  398. // W 3 2 _ M a r k e r P o i n t N o t e                                      //
    399. 

  399. ////////////////////////////////////////////////////////////////////////////////
    400. 

  400. W32_MarkerPointNote :: W32_MarkerPointNote ( int x, int y ) :
    401. 

  401.                         W32_PointNote ( x, y ) {
    402. 

  402. 

  403. }  // end constructor
    404. 

  404. 

  405. void W32_MarkerPointNote :: Play ( BOOL fDummy ) {
    406. 

  406. 

  407.  ALLOCATOR -> myHDC.SetPixel (  myX, myY, ALLOCATOR -> myMarkerPointColor  );
    408. 

  408. 

  409. }  // end W32_MarkerPointNote :: Play
    410. 

  410. ////////////////////////////////////////////////////////////////////////////////
    411. 

  411. // W 3 2 _ L i n e N o t e                                                    //
    412. 

  412. ////////////////////////////////////////////////////////////////////////////////
    413. 

  413. W32_LineNote :: W32_LineNote ( int x, int y, int x1, int y1 ) :
    414. 

  414.                  W32_PointNote ( x, y ) {
    415. 

  415. 

  416.  myX2 = x1;
    417. 

  417.  myY2 = y1;
    418. 

  418. 

  419. }  // end constructor
    420. 

  420. 

  421. void W32_LineNote :: Play ( BOOL fDummy ) {
    422. 

  422. 

  423.  EHDC* pe = &ALLOCATOR -> myHDC;
    424. 

  424. 

  425.  pe -> MoveToEx ( myX,  myY, NULL );
    426. 

  426.  pe -> LineTo   ( myX2, myY2      );
    427. 

  427. 

  428. }  // end W32_LineNote :: Play
    429. 

  429. ////////////////////////////////////////////////////////////////////////////////
    430. 

  430. // W 3 2 _ P o l y E l l i p s e N o t e                                      //
    431. 

  431. ////////////////////////////////////////////////////////////////////////////////
    432. 

  432. W32_PolyEllipseNote :: W32_PolyEllipseNote ( int xc, int yc, int xr, int yr ) :
    433. 

  433.                         W32_PointNote ( xc, yc ) {
    434. 

  434.                         
    435. 

  435.  myXr = xr;
    436. 

  436.  myYr = yr;                        
    437. 

  437.                         
    438. 

  438. }  // end constructor
    439. 

  439. 

  440. void W32_PolyEllipseNote :: Play ( BOOL fDummy ) {
    441. 

  441. 

  442.  ALLOCATOR -> myHDC.Polyarc ( myX, myY, myXr, myYr );
    443. 

  443. 

  444. }  // end W32_PolyEllipseNote :: Play
    445. 

  445. ////////////////////////////////////////////////////////////////////////////////
    446. 

  446. // W 3 2 _ E l l i p s e N o t e                                              //
    447. 

  447. ////////////////////////////////////////////////////////////////////////////////
    448. 

  448. W32_EllipseNote :: W32_EllipseNote ( int xc, int yc, int xr, int yr ) :
    449. 

  449.                     W32_PolyEllipseNote ( xc, yc, xr, yr ) {
    450. 

  450.                         
    451. 

  451. }  // end constructor
    452. 

  452. 

  453. void W32_EllipseNote :: Play ( BOOL fDummy ) {
    454. 

  454. 

  455.  ALLOCATOR -> myHDC.Arc ( myX, myY, myXr, myYr );
    456. 

  456. 

  457. }  // end W32_PolyEllipseNote :: Play
    458. 

  458. ////////////////////////////////////////////////////////////////////////////////
    459. 

  459. // W 3 2 _ A r c N o t e                                                      //
    460. 

  460. ////////////////////////////////////////////////////////////////////////////////
    461. 

  461. W32_ArcNote :: W32_ArcNote (
    462. 

  462.                 int xc, int yc, int xr, int yr, double sa, double oa
    463. 

  463.                ) : W32_PolyEllipseNote ( xc, yc, xr, yr ) {
    464. 

  464. 

  465.  mySa = sa;
    466. 

  466.  myOa = oa;
    467. 

  467. 

  468. }  // end constructor
    469. 

  469. 

  470. void W32_ArcNote :: Play ( BOOL fDummy ) {
    471. 

  471. 

  472.  ALLOCATOR -> myHDC.Arc ( myX, myY, myXr, myYr, mySa, myOa );
    473. 

  473. 

  474. }  // end W32_ArcNote :: Play
    475. 

  475. ////////////////////////////////////////////////////////////////////////////////
    476. 

  476. // W 3 2 _ P o l y C h o r d N o t e                                          //
    477. 

  477. ////////////////////////////////////////////////////////////////////////////////
    478. 

  478. W32_PolyChordNote :: W32_PolyChordNote (
    479. 

  479.                       int xc, int yc, int xr, int yr, double sa, double oa
    480. 

  480.                      ) : W32_ArcNote ( xc, yc, xr, yr, sa, oa ) {
    481. 

  481. 

  482. }  // end constructor
    483. 

  483. 

  484. void W32_PolyChordNote :: Play ( BOOL fDummy ) {
    485. 

  485. 

  486.  ALLOCATOR -> myHDC.Polyarc ( myX, myY, myXr, myYr, mySa, myOa );
    487. 

  487. 

  488. }  // end W32_PolyChordNote :: Play
    489. 

  489. ////////////////////////////////////////////////////////////////////////////////
    490. 

  490. // W 3 2 _ C h o r d N o t e                                                  //
    491. 

  491. ////////////////////////////////////////////////////////////////////////////////
    492. 

  492. W32_ChordNote :: W32_ChordNote (
    493. 

  493.                   int xc, int yc, int xr, int yr, double sa, double oa
    494. 

  494.                  ) : W32_PolyChordNote ( xc, yc, xr, yr, sa, oa ) {
    495. 

  495. 

  496. }  // end constructor
    497. 

  497. 

  498. void W32_ChordNote :: Play ( BOOL fDummy ) {
    499. 

  499. 

  500.  ALLOCATOR -> myHDC.Arc ( myX, myY, myXr, myYr, mySa, myOa );
    501. 

  501. 

  502. }  // end W32_ChordNote :: Play
    503. 

  503. ////////////////////////////////////////////////////////////////////////////////
    504. 

  504. // W 3 2 _ P o l y S e c t o r N o t e                                        //
    505. 

  505. ////////////////////////////////////////////////////////////////////////////////
    506. 

  506. W32_PolySectorNote :: W32_PolySectorNote (
    507. 

  507.                       int xc, int yc, int xr, int yr, double sa, double oa
    508. 

  508.                      ) : W32_ArcNote ( xc, yc, xr, yr, sa, oa ) {
    509. 

  509. 

  510. }  // end constructor
    511. 

  511. 

  512. void W32_PolySectorNote :: Play ( BOOL fDummy ) {
    513. 

  513. 

  514.  ALLOCATOR -> myHDC.Polyarc ( myX, myY, myXr, myYr, mySa, myOa, FALSE );
    515. 

  515. 

  516. }  // end W32_PolySectorNote :: Play
    517. 

  517. ////////////////////////////////////////////////////////////////////////////////
    518. 

  518. // W 3 2 _ S e c t o r N o t e                                                //
    519. 

  519. ////////////////////////////////////////////////////////////////////////////////
    520. 

  520. W32_SectorNote :: W32_SectorNote (
    521. 

  521.                   int xc, int yc, int xr, int yr, double sa, double oa
    522. 

  522.                  ) : W32_PolySectorNote ( xc, yc, xr, yr, sa, oa ) {
    523. 

  523. 

  524. }  // end constructor
    525. 

  525. 

  526. void W32_SectorNote :: Play ( BOOL fDummy ) {
    527. 

  527. 

  528.  ALLOCATOR -> myHDC.Arc ( myX, myY, myXr, myYr, mySa, myOa, ARCF_PIE );
    529. 

  529. 

  530. }  // end W32_SectorNote :: Play
    531. 

  531. ////////////////////////////////////////////////////////////////////////////////
    532. 

  532. // W 3 2 _ P o l y M a r k e r N o t e                                        //
    533. 

  533. ////////////////////////////////////////////////////////////////////////////////
    534. 

  534. W32_PolyMarkerNote :: W32_PolyMarkerNote ( int aMaxPoints ) {
    535. 

  535. 

  536.  myMaxPoints = aMaxPoints;
    537. 

  537.  mySetPoints = 0;
    538. 

  538.  myPoints    = ( LPPOINT )myAllocator -> NewData (
    539. 

  539.                                           myMaxPoints * sizeof ( POINT )
    540. 

  540.                                          );
    541. 

  541. 

  542. }  // end constructor
    543. 

  543. 

  544. void W32_PolyMarkerNote :: Replace ( int idx, int x, int y ) {
    545. 

  545. 

  546.  if ( idx >= myMaxPoints ) return;
    547. 

  547. 

  548.  myPoints[ idx ].x = x;   
    549. 

  549.  myPoints[ idx ].y = y;
    550. 

  550. 

  551. }  // end CPolyMarkerNote :: Replace
    552. 

  552. ////////////////////////////////////////////////////////////////////////////////
    553. 

  553. // W 3 2 _ P o l y M a r k e r 1 N o t e                                      //
    554. 

  554. ////////////////////////////////////////////////////////////////////////////////
    555. 

  555. W32_PolyMarker1Note :: W32_PolyMarker1Note (
    556. 

  556.                         int aMaxPoints, GetPointFunc fn, int aStartPoint,
    557. 

  557.                         void* fParam
    558. 

  558.                        ) : W32_PolyMarkerNote ( aMaxPoints ) {
    559. 

  559. 

  560.  ( *fn ) ( aStartPoint, myMaxPoints, aStartPoint, myPoints, &mySetPoints, fParam );
    561. 

  561.                        
    562. 

  562. }  // end constructor
    563. 

  563. 

  564. void W32_PolyMarker1Note :: Play ( BOOL fDummy ) {
    565. 

  565. 

  566.  if ( ALLOCATOR -> myFlags & W32F_MFILL )
    567. 

  567. 

  568.   ALLOCATOR -> myHDC.Polygon (
    569. 

  569.                       myPoints, mySetPoints,
    570. 

  570.                       POLYF_NOCLOSEDGE
    571. 

  571.                      );
    572. 

  572. 

  573.  else
    574. 

  574.                 
    575. 

  575.   ALLOCATOR -> myHDC.Polyline ( myPoints, mySetPoints );
    576. 

  576. 

  577. }  // end W32_PolyMarker1Note :: Play
    578. 

  578. ////////////////////////////////////////////////////////////////////////////////
    579. 

  579. // W 3 2 _ P o l y M a r k e r 2 N o t e                                      //
    580. 

  580. ////////////////////////////////////////////////////////////////////////////////
    581. 

  581. W32_PolyMarker2Note :: W32_PolyMarker2Note (
    582. 

  582.                         int aMaxPoints, GetPointFunc fn, int aStartPoint,
    583. 

  583.                         void* fParam
    584. 

  584.                        ) : W32_PolyMarker1Note (
    585. 

  585.                             aMaxPoints, fn, aStartPoint, fParam
    586. 

  586.                            ) {
    587. 

  587. 

  588. }  // end constructor
    589. 

  589. 

  590. void W32_PolyMarker2Note :: Play ( BOOL fDummy ) {
    591. 

  591. 

  592.  if ( ALLOCATOR -> myFlags & W32F_MFILL )
    593. 

  593. 

  594.   ALLOCATOR -> myHDC.Polygon ( myPoints, mySetPoints - 1 );
    595. 

  595. 

  596.  else
    597. 

  597.                 
    598. 

  598.   ALLOCATOR -> myHDC.Polyline ( myPoints, mySetPoints - 1, TRUE );
    599. 

  599. 

  600. }  // end W32_PolyMarker2Note :: Play
    601. 

  601. ////////////////////////////////////////////////////////////////////////////////
    602. 

  602. // W 3 2 _ P o l y g o n N o t e                                              //
    603. 

  603. ////////////////////////////////////////////////////////////////////////////////
    604. 

  604. W32_PolygonNote :: W32_PolygonNote ( int aMaxPoints ) :
    605. 

  605.                     W32_PolyMarkerNote ( aMaxPoints ) {
    606. 

  606.                                                             
    607. 

  607. }  // end constructor
    608. 

  608. 

  609. void W32_PolygonNote :: Play ( BOOL fDummy ) {
    610. 

  610.   
    611. 

  611.  ALLOCATOR -> myHDC.Polygon (
    612. 

  612.                      myPoints, mySetPoints,
    613. 

  613.                      ALLOCATOR -> myFlags & W32F_POUTL ? 0 : POLYF_NOEDGE
    614. 

  614.                     );
    615. 

  615.  
    616. 

  616. }  // end W32_PolygonNote :: Play
    617. 

  617. 

  618. void W32_PolygonNote :: Add ( int aX,int aY ) {
    619. 

  619. 

  620.  if ( mySetPoints == myMaxPoints ) return;
    621. 

  621. 

  622.  ( myPoints + mySetPoints ) -> x = aX;
    623. 

  623.  ( myPoints + mySetPoints ) -> y = aY;
    624. 

  624.  
    625. 

  625.  ++mySetPoints;
    626. 

  626. 

  627. }  // end W32_CPolygonNote :: Add
    628. 

  628. ////////////////////////////////////////////////////////////////////////////////
    629. 

  629. // W 3 2 _ P o l y l i n e N o t e                                            //
    630. 

  630. ////////////////////////////////////////////////////////////////////////////////
    631. 

  631. W32_PolylineNote :: W32_PolylineNote ( int aMaxPoints ) :
    632. 

  632.                      W32_PolygonNote ( aMaxPoints ) {
    633. 

  633.                      
    634. 

  634. }  // end constructor
    635. 

  635. 

  636. void W32_PolylineNote :: Play ( BOOL fDummy ) {
    637. 

  637. 

  638.  DWORD nPts;
    639. 

  639.  BOOL  fClose;
    640. 

  640.  int   idx = mySetPoints - 1;
    641. 

  641. 

  642.  if ( myPoints -> x == myPoints[ idx ].x &&
    643. 

  643.       myPoints -> y == myPoints[ idx ].y
    644. 

  644.  ) {
    645. 

  645.  
    646. 

  646.   nPts   = idx;
    647. 

  647.   fClose = TRUE;
    648. 

  648.  
    649. 

  649.  } else {
    650. 

  650.  
    651. 

  651.   nPts   = mySetPoints;
    652. 

  652.   fClose = FALSE;
    653. 

  653.  
    654. 

  654.  }  // end else
    655. 

  655. 

  656.  ALLOCATOR -> myHDC.Polyline ( myPoints, nPts, fClose );
    657. 

  657. 

  658. }  // end W32_PolylineNote :: Play
    659. 

  659. ////////////////////////////////////////////////////////////////////////////////
    660. 

  660. // W 3 2 _ I m a g e N o t e                                                  //
    661. 

  661. ////////////////////////////////////////////////////////////////////////////////
    662. 

  662. W32_ImageNote :: W32_ImageNote (
    663. 

  663.                   int x, int y, PW32_Bitmap pBmp, double aScale
    664. 

  664.                  ) : W32_PointNote ( x, y ) {
    665. 

  665. 

  666.  myBitmap = pBmp;
    667. 

  667.  ++pBmp   -> nUsed;
    668. 

  668.  myScale  = aScale;
    669. 

  669. 

  670. }  // end constructor
    671. 

  671. 

  672. W32_ImageNote :: ~W32_ImageNote () {
    673. 

  673. 

  674.  if ( myBitmap -> hBmp != NULL && --myBitmap -> nUsed == 0 ) {
    675. 

  675.  
    676. 

  676.   DeleteObject ( myBitmap -> hBmp );
    677. 

  677.   HeapFree (  GetProcessHeap (), 0, ( PVOID )myBitmap  );
    678. 

  678. 

  679.  }  // end if
    680. 

  680. 

  681. }  // end W32_ImageNote :: ~W32_ImageNote
    682. 

  682. 

  683. void W32_ImageNote :: Play ( BOOL fDummy ) {
    684. 

  684. 

  685.  int     xx, yy, w, h;
    686. 

  686.  HDC     hdc, hdcMem;
    687. 

  687.  BITMAP  bmp;
    688. 

  688.  HBITMAP hbo;
    689. 

  689.  SIZE    sz;
    690. 

  690.  POINT   up[ 4 ];
    691. 

  691.  BOOL    fScale = FALSE;
    692. 

  692. 

  693.  ALLOCATOR -> myHDC.Extent ( &sz );
    694. 

  694.  GetObject (  myBitmap -> hBmp, sizeof ( BITMAP ), &bmp  );
    695. 

  695. 

  696.  xx = myX;
    697. 

  697.  yy = myY;
    698. 

  698.  w  = bmp.bmWidth;
    699. 

  699.  h  = bmp.bmHeight;
    700. 

  700. 

  701.  if ( myScale != 1.0 ) {
    702. 

  702.   
    703. 

  703.   w  = int (  w * myScale + 0.5 );
    704. 

  704.   h  = int (  h * myScale + 0.5 );
    705. 

  705.  
    706. 

  706.   fScale = TRUE;
    707. 

  707.  
    708. 

  708.  }
    709. 

  709.  
    710. 

  710.  if ( ALLOCATOR -> myScaleX != 1.0 ) {
    711. 

  711.   
    712. 

  712.   xx = int ( xx * ALLOCATOR -> myScaleX + 0.5 );
    713. 

  713.   w  = int (  w * ALLOCATOR -> myScaleX + 0.5 );
    714. 

  714. 

  715.   fScale = TRUE;
    716. 

  716. 

  717.  }  // end if
    718. 

  718. 

  719.  if ( ALLOCATOR -> myScaleY != 1.0 ) {
    720. 

  720.  
    721. 

  721.   yy = int ( yy * ALLOCATOR -> myScaleY + 0.5 );
    722. 

  722.   h  = int (  h * ALLOCATOR -> myScaleY + 0.5 );
    723. 

  723. 

  724.   fScale = TRUE;
    725. 

  725. 

  726.  }  // end if
    727. 

  727. 

  728.  xx = xx    -         ( w >> 1 )    + ALLOCATOR -> myPivot.x + ALLOCATOR -> myMove.x ;
    729. 

  729.  yy = sz.cy - (  yy + ( h >> 1 )  ) - ALLOCATOR -> myPivot.y - ALLOCATOR -> myMove.y;
    730. 

  730. 

  731.  hdc = ALLOCATOR -> myHDC.Hdc ();
    732. 

  732.  hdcMem = CreateCompatibleDC ( hdc );
    733. 

  733.   hbo = SelectBitmap( hdcMem, myBitmap -> hBmp );
    734. 

  734. 

  735.    if (  ALLOCATOR -> myAngle == 0.0  ) {
    736. 

  736.    
    737. 

  737.     StretchBlt (
    738. 

  738.      hdc,    xx, yy,           w,            h,
    739. 

  739.      hdcMem,  0,  0, bmp.bmWidth, bmp.bmHeight,
    740. 

  740.      SRCCOPY
    741. 

  741.     );
    742. 

  742. 

  743.     up[ 0 ].x = xx;        up[ 0 ].y = yy;
    744. 

  744.     up[ 1 ].x = xx + w;    up[ 1 ].y = up[ 0 ].y;
    745. 

  745.     up[ 2 ].x = up[ 1 ].x; up[ 2 ].y = yy + h;
    746. 

  746.     up[ 3 ].x = up[ 0 ].x; up[ 3 ].y = up[ 2 ].y;
    747. 

  747. 

  748.     ALLOCATOR -> myHDC.Register ( up, 4 );
    749. 

  749. 

  750.    } else {
    751. 

  751.    
    752. 

  752.     int     i, j;
    753. 

  753.     int     x1      = xx;
    754. 

  754.     int     y1      = sz.cy - yy - h;
    755. 

  755.     int     x2      = x1 + w;
    756. 

  756.     int     y2      = y1;
    757. 

  757.     int     x3      = x2;
    758. 

  758.     int     y3      = y1 + h;
    759. 

  759.     int     x4      = x1;
    760. 

  760.     int     y4      = y3;
    761. 

  761.     int     xmin    = MIN4( x1, x2, x3, x4 );
    762. 

  762.     int     ymin    = MIN4( y1, y2, y3, y4 );
    763. 

  763.     double  DeltaX  = cos ( -ALLOCATOR -> myAngle );
    764. 

  764.     double  DeltaY  = sin ( -ALLOCATOR -> myAngle );
    765. 

  765.     int     X1      = int (  x1 * DeltaX + y1 * DeltaY ); 
    766. 

  766.     int     Y1      = int ( -x1 * DeltaY + y1 * DeltaX );
    767. 

  767.     int     X2      = int (  x2 * DeltaX + y2 * DeltaY );
    768. 

  768.     int     Y2      = int ( -x2 * DeltaY + y2 * DeltaX );
    769. 

  769.     int     X3      = int (  x3 * DeltaX + y3 * DeltaY );
    770. 

  770.     int     Y3      = int ( -x3 * DeltaY + y3 * DeltaX );
    771. 

  771.     int     X4      = int (  x4 * DeltaX + y4 * DeltaY );
    772. 

  772.     int     Y4      = int ( -x4 * DeltaY + y4 * DeltaX );
    773. 

  773.     int     YHeight = max(  abs ( Y1 - Y3 ), abs ( Y2 - Y4 )  ) + 1;
    774. 

  774.     int     Ymin    = MIN4( Y1, Y2, Y3, Y4 );
    775. 

  775.     PINT    line1, line2, line3, line4;
    776. 

  776.     PPOINT  lines;
    777. 

  777.     HBITMAP hbo2, hBmp;
    778. 

  778. 

  779.     if ( fScale ) {
    780. 

  780. 

  781.      HDC hdcMem2 = CreateCompatibleDC ( hdc );
    782. 

  782.       hBmp = CreateCompatibleBitmap ( hdc, w, h );
    783. 

  783. 

  784.        hbo2 = SelectBitmap( hdcMem2, hBmp );
    785. 

  785.         StretchBlt (
    786. 

  786.          hdcMem2, 0, 0,           w,            h,
    787. 

  787.          hdcMem,  0, 0, bmp.bmWidth, bmp.bmHeight,
    788. 

  788.          SRCCOPY
    789. 

  789.         );
    790. 

  790.        SelectBitmap( hdcMem2, hbo2 );
    791. 

  791.      DeleteDC ( hdcMem2 );
    792. 

  792. 

  793.      hbo2 = SelectBitmap( hdcMem,  hBmp );
    794. 

  794. 

  795.     }  // end if
    796. 

  796. 

  797.     lines = ( PPOINT )VirtualAlloc (
    798. 

  798.                        NULL, (   (  j = ( sizeof ( int ) * YHeight )  ) << 2   ) +
    799. 

  799.                              (      i = YHeight * sizeof ( POINT )             ),
    800. 

  800.                        MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE
    801. 

  801.                       );
    802. 

  802. 

  803.      line1 = PINT (   (  ( PBYTE )lines  ) + i   );
    804. 

  804.      line2 = PINT (   (  ( PBYTE )line1  ) + j   );
    805. 

  805.      line3 = PINT (   (  ( PBYTE )line2  ) + j   );
    806. 

  806.      line4 = PINT (   (  ( PBYTE )line3  ) + j   );
    807. 

  807. 

  808.      for ( i = 0; i < YHeight; ++i )
    809. 

  809.     
    810. 

  810.       line1[ i ] = line2[ i ] = line3[ i ] = line4[ i ] = INT_MAX;
    811. 

  811. 

  812.      LineDDA (  X1, Y1 - Ymin, X2, Y2 - Ymin, &_LineDDAProc, ( LPARAM )line1  );
    813. 

  813.      LineDDA (  X2, Y2 - Ymin, X3, Y3 - Ymin, &_LineDDAProc, ( LPARAM )line2  );
    814. 

  814.      LineDDA (  X3, Y3 - Ymin, X4, Y4 - Ymin, &_LineDDAProc, ( LPARAM )line3  );
    815. 

  815.      LineDDA (  X4, Y4 - Ymin, X1, Y1 - Ymin, &_LineDDAProc, ( LPARAM )line4  );
    816. 

  816. 

  817.      for ( i = 0; i < YHeight; ++i ) {
    818. 

  818. 

  819.       lines[ i ].x = MIN4( line1[ i ], line2[ i ], line3[ i ], line4[ i ] );
    820. 

  820.   
    821. 

  821.       if ( lines[ i ].x < 0 ) lines[ i ].x = 0;
    822. 

  822. 

  823.       lines[ i ].y = MAX4( line1[ i ], line2[ i ], line3[ i ], line4[ i ] );
    824. 

  824. 

  825.      }  // end for
    826. 

  826. 

  827.      for (  j = ( -Ymin < 0 ? 0 : -Ymin ); j < YHeight; ++j  ) {
    828. 

  828. 

  829.       int    Yt = sz.cy - ( j + Ymin );
    830. 

  830.       int    Yy = j + Ymin;
    831. 

  831.       double XB =       lines[ j ].x * DeltaX - Yy * DeltaY - xmin;
    832. 

  832.       double YB = h - ( lines[ j ].x * DeltaY + Yy * DeltaX - ymin );
    833. 

  833. 

  834.       up[ 0 ].x = lines[ j ].x; up[ 0 ].y = Yt;
    835. 

  835.       up[ 1 ].x = lines[ j ].y; up[ 1 ].y = Yt;
    836. 

  836. 

  837.       ALLOCATOR -> myHDC.Register ( up, 2 );
    838. 

  838. 

  839.       for ( i = lines[ j ].x; i <= lines[ j ].y; ++i ) {
    840. 

  840. 

  841.        SetPixel (
    842. 

  842.         hdc, i, Yt, GetPixel (  hdcMem, ( int )XB, ( int )YB  )
    843. 

  843.        );
    844. 

  844. 

  845.        XB += DeltaX; YB -= DeltaY;
    846. 

  846.      
    847. 

  847.       }  // end for ( i )
    848. 

  848. 

  849.      }  // end for ( j )
    850. 

  850. 

  851.     VirtualFree (  ( LPVOID )lines, 0, MEM_DECOMMIT | MEM_RELEASE  );
    852. 

  852. 

  853.     if ( fScale ) {
    854. 

  854. 

  855.      SelectBitmap( hdcMem, hbo2 );
    856. 

  856.      DeleteBitmap( hBmp );
    857. 

  857.     
    858. 

  858.     }  // end if
    859. 

  859. 

  860.     ALLOCATOR -> Xform ();
    861. 

  861.    
    862. 

  862.    }  // end else
    863. 

  863. 

  864.   SelectBitmap( hdcMem, hbo );
    865. 

  865.  DeleteDC ( hdcMem );
    866. 

  866. 

  867. }  // end W32_ImageNote :: Play
    868. 

  868. ////////////////////////////////////////////////////////////////////////////////
    869. 

  869. // W 3 2 _ T e x t N o t e                                                    //
    870. 

  870. ////////////////////////////////////////////////////////////////////////////////
    871. 

  871. W32_TextNote :: W32_TextNote (
    872. 

  872.                  int x, int y, double angle, void* text,
    873. 

  873.                  BOOL fWide, BOOL fOutlined
    874. 

  874.                 ) : W32_PointNote ( x, y ), myAngle ( angle ) {
    875. 

  875.              
    876. 

  876.  DWORD dwLen = fWide ? (    (   lstrlenW (  ( LPCWSTR )text  ) + 1   ) << 1    )
    877. 

  877.                      : (    (   lstrlenA (  ( LPCSTR  )text  ) + 1   ) << 0    );
    878. 

  878. 

  879.  myText = ALLOCATOR -> NewData ( dwLen );
    880. 

  880.  CopyMemory ( myText, text, dwLen );
    881. 

  881. 

  882.  myFlags = (  ( fWide     ? W32F_TUNICODE : 0 ) |
    883. 

  883.               ( fOutlined ? W32F_TOUTLINE : 0 )
    884. 

  884.            );
    885. 

  885.                 
    886. 

  886. }  // end constructor
    887. 

  887. 

  888. void W32_TextNote :: Play ( BOOL fDummy ) {
    889. 

  889. 

  890.  if ( myFlags & W32F_TUNICODE )
    891. 

  891. 

  892.   ALLOCATOR -> myHDC.ETextOut (
    893. 

  893.    myX, myY, ( wchar_t* )myText, myAngle,
    894. 

  894.    myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO
    895. 

  895.   );
    896. 

  896. 

  897.  else
    898. 

  898. 

  899.   ALLOCATOR -> myHDC.ETextOut (
    900. 

  900.    myX, myY, ( char* )myText, myAngle,
    901. 

  901.    myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO
    902. 

  902.   );
    903. 

  903. 

  904. }  // end W32_TextNote :: Play
    905. 

  905. ////////////////////////////////////////////////////////////////////////////////
    906. 

  906. // W 3 2 _ P o l y T e x t N o t e                                            //
    907. 

  907. ////////////////////////////////////////////////////////////////////////////////
    908. 

  908. W32_PolyTextNote :: W32_PolyTextNote (
    909. 

  909.                      int x, int y, double angle, double margin,
    910. 

  910.                      void* text, BOOL fWide, BOOL fOutlined
    911. 

  911.                     ) : W32_TextNote ( x, y, angle, text, fWide, fOutlined ),
    912. 

  912.                         myMargin ( margin ) {
    913. 

  913. 

  914. }  // end constructor
    915. 

  915. 

  916. void W32_PolyTextNote :: Play ( BOOL fDummy ) {
    917. 

  917. 

  918.  BOOL fNofill  = ( ALLOCATOR -> myFlags & W32F_NOFIL ? TRUE  : FALSE );
    919. 

  919.  BOOL fNoframe = ( ALLOCATOR -> myFlags & W32F_POUTL ? FALSE : TRUE  );
    920. 

  920. 

  921.  if ( myFlags & W32F_TUNICODE )
    922. 

  922. 

  923.   ALLOCATOR -> myHDC.PolyTextOut (
    924. 

  924.    myX, myY, ( wchar_t* )myText, myAngle,
    925. 

  925.    myMargin, myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO, fNofill,
    926. 

  926.    fNoframe
    927. 

  927.   );
    928. 

  928. 

  929.  else
    930. 

  930. 

  931.   ALLOCATOR -> myHDC.PolyTextOut (
    932. 

  932.    myX, myY, ( char* )myText, myAngle,
    933. 

  933.    myMargin, myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO, fNofill,
    934. 

  934.    fNoframe
    935. 

  935.   );
    936. 

  936. 

  937. }  // end W32_PolyTextNote :: Play
    938. 

  938. ////////////////////////////////////////////////////////////////////////////////
    939. 

  939. // W 3 2 _ B e g i n M a r k e r N o t e                                      //
    940. 

  940. ////////////////////////////////////////////////////////////////////////////////
    941. 

  941. W32_BeginMarkerNote :: W32_BeginMarkerNote (
    942. 

  942.                         int x, int y, int w, int h, double angle
    943. 

  943.                        ) : W32_PointNote ( x, y ),
    944. 

  944.                            myAngle ( angle ), myWidth ( w ), myHeight ( h ) {                
    945. 

  945. 

  946. }  // end constructor
    947. 

  947. 

  948. void W32_BeginMarkerNote :: Play ( BOOL fDummy ) {
    949. 

  949. 

  950.  XFORM    xfm;
    951. 

  951.  LOGBRUSH lb = { BS_SOLID, ALLOCATOR -> myMarkerPointColor, 0 };
    952. 

  952.  POINT    p  = { myX, myY };
    953. 

  953. 

  954.  if ( ALLOCATOR -> myFlags & W32F_XFORM ) ALLOCATOR -> myHDC.Transform ( &p, 1 );
    955. 

  955. 

  956.  _InitXform ( &xfm, myAngle, p.x, p.y );
    957. 

  957.  
    958. 

  958.  ALLOCATOR -> myHDC.SetWorldTransform ( &xfm );
    959. 

  959.  ALLOCATOR -> myHDC.SelectEPen (
    960. 

  960.                      ALLOCATOR -> myMarkerWidth, &lb
    961. 

  961.                     );
    962. 

  962.  ALLOCATOR -> myHDC.SelectEBrush (
    963. 

  963.                      &ALLOCATOR -> myMarkerBrush,
    964. 

  964.                      &ALLOCATOR -> myMarkerBrushOrig
    965. 

  965.                     );
    966. 

  966. 

  967. }  // end W32_BeginMarkerNote :: Play
    968. 

  968. ////////////////////////////////////////////////////////////////////////////////
    969. 

  969. // W 3 2 _ E n d M a r k e r N o t e                                          //
    970. 

  970. ////////////////////////////////////////////////////////////////////////////////
    971. 

  971. W32_EndMarkerNote :: W32_EndMarkerNote () {}
    972. 

  972. 

  973. void W32_EndMarkerNote :: Play ( BOOL fDummy ) {
    974. 

  974. 

  975.  ALLOCATOR -> Xform ();
    976. 

  976.  ALLOCATOR -> myHDC.SelectEPen ( 0xFFFFFFFF, NULL );
    977. 

  977.  ALLOCATOR -> myHDC.SelectEBrush ( &ALLOCATOR -> myMarkerBrushOrig );
    978. 

  978. 

  979. }  // end W32_EndMarkerNote :: Play
    980. 

  980. 

  981. ////////////////////////////////////////////////////////////////////////////////
    982. 

  982. ////////////////////////////////////////////////////////////////////////////////
    983. 

  983. ////////////////////////////////////////////////////////////////////////////////
    984. 

  984. #define SET_ATTRIB \
    985. 

  985.   ( ((ALLOCATOR->myFlags & W32F_MONO) && (ALLOCATOR->myFlags & W32F_MINIT)) ||\
    986. 

  986.     !(ALLOCATOR->myFlags & W32F_MONO)\
    987. 

  987.   )
    988. 

  988. ////////////////////////////////////////////////////////////////////////////////
    989. 

  989. // W 3 2 _ L i n e A t t r i b N o t e                                        //
    990. 

  990. ////////////////////////////////////////////////////////////////////////////////
    991. 

  991. W32_LineAttribNote :: W32_LineAttribNote (
    992. 

  992.                        DWORD width, PLOGBRUSH plb,
    993. 

  993.                        DWORD nStyles, PDWORD pdwStyle
    994. 

  994.                       ) {
    995. 

  995.                    
    996. 

  996.  myPenWidth   = width;                         
    997. 

  997.  myLogBrush   = *plb;
    998. 

  998.  myStyleCount = nStyles;
    999. 

  999. 

  1000.  if ( myStyleCount != 0 ) {
    1001. 

  1001. 

  1002.   DWORD dwLen = nStyles * sizeof ( DWORD );
    1003. 

  1003. 

  1004.   myStyles = ( PDWORD )ALLOCATOR -> NewData ( dwLen );
    1005. 

  1005. 

  1006.   CopyMemory ( myStyles, pdwStyle, dwLen );
    1007. 

  1007. 

  1008.  }  // end if
    1009. 

  1009. 

  1010.  Play ( FALSE );
    1011. 

  1011.                       
    1012. 

  1012. }  // end constructor
    1013. 

  1013. 

  1014. void W32_LineAttribNote :: Play ( BOOL fRealize ) {
    1015. 

  1015. 

  1016.  ALLOCATOR -> myPointColor   = myLogBrush.lbColor;
    1017. 

  1017.  ALLOCATOR -> myLineBrush    = myLogBrush;
    1018. 

  1018.  ALLOCATOR -> myLinePenWidth = myPenWidth;
    1019. 

  1019. 

  1020.  if ( myStyleCount != 0 ) {
    1021. 

  1021. 

  1022.   DWORD dwLen = myStyleCount * sizeof ( DWORD );
    1023. 

  1023. 

  1024.   if ( ALLOCATOR -> myLineStyles != NULL )
    1025. 

  1025. 

  1026.    ALLOCATOR -> myLineStyles = ( PDWORD )HeapReAlloc (
    1027. 

  1027.                                           GetProcessHeap (),
    1028. 

  1028.                                           HEAP_GENERATE_EXCEPTIONS,
    1029. 

  1029.                                           ALLOCATOR -> myLineStyles,
    1030. 

  1030.                                           dwLen
    1031. 

  1031.                                          );
    1032. 

  1032. 

  1033.   else
    1034. 

  1034. 

  1035.    ALLOCATOR -> myLineStyles = ( PDWORD )HeapAlloc (
    1036. 

  1036.                                           GetProcessHeap (),
    1037. 

  1037.                                           HEAP_GENERATE_EXCEPTIONS,
    1038. 

  1038.                                           dwLen
    1039. 

  1039.                                          );
    1040. 

  1040. 

  1041.   CopyMemory ( ALLOCATOR -> myLineStyles, myStyles, dwLen );
    1042. 

  1042.   ALLOCATOR -> myLineStyleCount = myStyleCount;
    1043. 

  1043. 

  1044.  }  // end if
    1045. 

  1045. 

  1046.  if ( fRealize ) ALLOCATOR -> myHDC.SelectEPen (
    1047. 

  1047.                                      myPenWidth, &myLogBrush,
    1048. 

  1048.                                      myStyleCount, myStyles
    1049. 

  1049.                                     );
    1050. 

  1050. 

  1051. }  // end W32_LineAttribNote :: Play
    1052. 

  1052. ////////////////////////////////////////////////////////////////////////////////
    1053. 

  1053. // W 3 2 _ P o l y A t t r i b N o t e                                        //
    1054. 

  1054. ////////////////////////////////////////////////////////////////////////////////
    1055. 

  1055. W32_PolyAttribNote :: W32_PolyAttribNote (
    1056. 

  1056.                        PLOGBRUSH plb, BOOL fDrawEdge, int aFillMode
    1057. 

  1057.                       ) {
    1058. 

  1058. 

  1059.  myBrush     = *plb;
    1060. 

  1060.  myfEdge     =  fDrawEdge;
    1061. 

  1061.  myFillMode  =  aFillMode;
    1062. 

  1062. 

  1063.  Play ( FALSE );
    1064. 

  1064. 

  1065. }  // end constructor
    1066. 

  1066. 

  1067. void W32_PolyAttribNote :: Play ( BOOL fRealize ) {
    1068. 

  1068. 

  1069.  ALLOCATOR -> myFillMode  = myFillMode;
    1070. 

  1070.  if ( myfEdge )     ALLOCATOR -> myFlags |= W32F_POUTL;
    1071. 

  1071.  else               ALLOCATOR -> myFlags &= ~W32F_POUTL;
    1072. 

  1072.  if ( myBrush.lbStyle == BS_NULL )  ALLOCATOR -> myFlags |= W32F_NOFIL;
    1073. 

  1073.  else                               ALLOCATOR -> myFlags &= ~W32F_NOFIL;
    1074. 

  1074. 

  1075.  ALLOCATOR -> myPolyBrush = myBrush;
    1076. 

  1076.  if ( fRealize ) {
    1077. 

  1077.   ALLOCATOR -> myHDC.SelectEBrush    ( &myBrush   );
    1078. 

  1078.   ALLOCATOR -> myHDC.SetPolyFillMode ( myFillMode );
    1079. 

  1079.  }  // end if
    1080. 

  1080. 

  1081. }  // end W32_PolyAttribNote :: Play
    1082. 

  1082. ////////////////////////////////////////////////////////////////////////////////
    1083. 

  1083. // W 3 2 _ T e x t A t t r i b N o t e                                        //
    1084. 

  1084. ////////////////////////////////////////////////////////////////////////////////
    1085. 

  1085. W32_TextAttribNote :: W32_TextAttribNote (
    1086. 

  1086.                        HFONT hFont, COLORREF color, double slant,
    1087. 

  1087.                        double hScale, double vScale,
    1088. 

  1088.                        BOOL fUnderlined, BOOL fFree, BOOL fIndex
    1089. 

  1089.                       ) {
    1090. 

  1090.                       
    1091. 

  1091.  myColor     = color;
    1092. 

  1092.  myFont      = hFont;
    1093. 

  1093.  mySlant     = slant;
    1094. 

  1094.  myHScale    = vScale;
    1095. 

  1095.  myVScale    = hScale;
    1096. 

  1096.  myFlags     = ( fUnderlined ? W32F_TFULINED : 0 ) |
    1097. 

  1097.                ( fIndex      ? W32F_TINDEX   : 0 ) |
    1098. 

  1098.                ( fFree       ? W32F_TFREE    : 0 );
    1099. 

  1099. 

  1100.  Play ( FALSE );
    1101. 

  1101.                       
    1102. 

  1102. }  // end constructor
    1103. 

  1103. 

  1104. W32_TextAttribNote :: ~W32_TextAttribNote () {
    1105. 

  1105. 

  1106.  if ( myFlags & W32F_TFREE ) DeleteFont( myFont );
    1107. 

  1107. 

  1108. }  // end destructor
    1109. 

  1109. 

  1110. void W32_TextAttribNote :: Play ( BOOL fRealize ) {
    1111. 

  1111. 

  1112.  if (  ( ALLOCATOR -> myFlags & W32F_DFONT ) && !( myFlags & W32F_TINDEX )  ) {
    1113. 

  1113.   DeleteFont( ALLOCATOR -> myTextFont );
    1114. 

  1114.   ALLOCATOR -> myFlags &= ~W32F_DFONT;
    1115. 

  1115.  }  // end if
    1116. 

  1116. 

  1117.  ALLOCATOR -> myTextFont   = myFont;
    1118. 

  1118.  ALLOCATOR -> myTextSlant  = mySlant;
    1119. 

  1119.  ALLOCATOR -> myTextHScale = myHScale;
    1120. 

  1120.  ALLOCATOR -> myTextVScale = myVScale;
    1121. 

  1121.  if ( myFlags & W32F_TFULINED )  ALLOCATOR -> myFlags |= W32F_TULIN;
    1122. 

  1122.  else                            ALLOCATOR -> myFlags &= ~W32F_TULIN;
    1123. 

  1123. 

  1124.  ALLOCATOR -> myTextColor  = myColor;
    1125. 

  1125.  if (  fRealize && !( myFlags & W32F_TINDEX )  )
    1126. 

  1126.   ALLOCATOR -> myHDC.SetTextAttrib (
    1127. 

  1127.                       myColor, myFont, mySlant,
    1128. 

  1128.                       myHScale, myVScale
    1129. 

  1129.                      );
    1130. 

  1130. 

  1131. }  // end W32_TextAttribNote :: Play
    1132. 

  1132. ////////////////////////////////////////////////////////////////////////////////
    1133. 

  1133. // W 3 2 _ M a r k e r A t t r i b N o t e                                    //
    1134. 

  1134. ////////////////////////////////////////////////////////////////////////////////
    1135. 

  1135. W32_MarkerAttribNote :: W32_MarkerAttribNote (
    1136. 

  1136.                          COLORREF color, DWORD dwWidth, BOOL fFill
    1137. 

  1137.                         ) {
    1138. 

  1138.                         
    1139. 

  1139.  myLogBrush.lbStyle = fFill;
    1140. 

  1140.  myLogBrush.lbColor = color;
    1141. 

  1141.  myLogBrush.lbHatch = dwWidth;
    1142. 

  1142. 

  1143.  Play ();
    1144. 

  1144. 

  1145. }  // end constructor
    1146. 

  1146. 

  1147. void W32_MarkerAttribNote :: Play ( BOOL fDummy ) {
    1148. 

  1148. 

  1149.  ALLOCATOR -> myMarkerBrush.lbStyle = BS_SOLID;
    1150. 

  1150.  ALLOCATOR -> myMarkerBrush.lbColor = ALLOCATOR -> myPolyBrush.lbColor;
    1151. 

  1151.  ALLOCATOR -> myMarkerBrush.lbHatch = 0;
    1152. 

  1152.  ALLOCATOR -> myMarkerWidth         = myLogBrush.lbHatch;
    1153. 

  1153.  ALLOCATOR -> myMarkerPointColor    = myLogBrush.lbColor;
    1154. 

  1154.  
    1155. 

  1155.  if ( myLogBrush.lbStyle )
    1156. 

  1156.   ALLOCATOR -> myFlags |= W32F_MFILL;
    1157. 

  1157.  else
    1158. 

  1158.   ALLOCATOR -> myFlags &= ~W32F_MFILL;
    1159. 

  1159. 

  1160. }  // end W32_MarkerAttribNote :: Play
    1161. 

  1161. ////////////////////////////////////////////////////////////////////////////////
    1162. 

  1162. // W 3 2 _ F C a l l N o t e                                                  //
    1163. 

  1163. ////////////////////////////////////////////////////////////////////////////////
    1164. 

  1164. W32_FCallNote :: W32_FCallNote (
    1165. 

  1165.                   W32_FCall fCall, int sz, PW32_FCALLPARAM param
    1166. 

  1166.                  ) {
    1167. 

  1167. 

  1168.  myFunc = fCall;
    1169. 

  1169. 

  1170.  myParam = ( PW32_FCALLPARAM )ALLOCATOR -> NewData ( sz );
    1171. 

  1171. 

  1172.  CopyMemory ( myParam, param, sz );
    1173. 

  1173. 

  1174. }  // end constructor
    1175. 

  1175. 

  1176. void W32_FCallNote :: Play ( BOOL fDummy ) {
    1177. 

  1177. 

  1178.  ( *myFunc ) ( myParam );
    1179. 

  1179. 

  1180. }  // end W32_FCallNote :: Play
    1181. 

  1181. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    1182. 

  1182. // M i s c e l l a n e o u s                                                 +//
    1183. 

  1183. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    1184. 

  1184. static void WINAPI _InitXform ( PXFORM pxf, double angle, int x, int y ) {
    1185. 

  1185. 

  1186.  double cosVal, sinVal;
    1187. 

  1187. 

  1188.  cosVal = cos ( angle );
    1189. 

  1189.  sinVal = sin ( angle );
    1190. 

  1190. 

  1191.  pxf -> eM11 = ( FLOAT ) cosVal; pxf -> eM12 = ( FLOAT )sinVal;
    1192. 

  1192.  pxf -> eM21 = ( FLOAT )-sinVal; pxf -> eM22 = ( FLOAT )cosVal;
    1193. 

  1193.  pxf -> eDx  = ( FLOAT )      x; pxf -> eDy  = ( FLOAT )     y;
    1194. 

  1194. 

  1195. }  // end _InitXform
    1196. 

  1196. 

  1197. static VOID CALLBACK _LineDDAProc ( int x, int y, LPARAM lpData ) {
    1198. 

  1198. 

  1199.  (  ( PINT )lpData   )[ y ] = x;
    1200. 

  1200. 

  1201. }  // end LineDDAProc
    1202. 

  1202. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    1203.