0f7b898fec93ebb5a8adc59e3f5c8acb9805f3c0
[occt.git] / src / WNT / WNT_Allocator.cxx
1 ////////////////////////////////////////////////////////////////////////////////
2 // WNT_Allocator                                                              //
3 //  Provides memory management and drawing operations for Windows 95.         //
4 //   World transformations and styled lines are managed by EHDC stuff.        //
5 //                                                                            //
6 // History: FEB-98 - creation (EUG)                                           //
7 //          MAR-98 - modification (DCB)                                       //
8 ////////////////////////////////////////////////////////////////////////////////
9
10 #define PRO19042        //GG_251199 Avoid to crash with an insuffisant resources messag
11
12 #include "WNT_Allocator.hxx"
13
14 #include <math.h>
15 #include <limits>
16 #include <stdio.h>
17
18 #define ALLOCATOR ( ( PWNT_Allocator )myAllocator )
19
20 static XFORM xfmIdent = { ( FLOAT )0.8660,  ( FLOAT )0.5000,
21                           ( FLOAT )-0.5000, ( FLOAT )0.8660,
22                           ( FLOAT )0.0000,  ( FLOAT )0.0000
23                         };
24
25 WNT_Allocator :: WNT_Allocator ( int anID, PW32_Allocator prev ) :
26                   W32_Allocator ( anID, prev )
27 {
28   myLinePen           = (HPEN)   GetStockObject ( NULL_PEN    );
29   myLineWidth         = 1;
30   myPolyBrush         = (HBRUSH) GetStockObject ( NULL_BRUSH  );
31   myTextPen           = (HPEN)   GetStockObject ( NULL_PEN    );
32   myTextBrush         = (HBRUSH) GetStockObject ( NULL_BRUSH  );
33   myTextFont          = (HFONT)  GetStockObject ( SYSTEM_FONT );
34   myMarkerPen         = (HPEN)   GetStockObject ( NULL_PEN    );
35   myTextSlant         = EPS;
36
37   myPO                = (HPEN)   NULL;
38   myBO                = (HBRUSH) NULL;
39   myFO                = (HFONT)  NULL;
40   SetRectEmpty        ( &myURect );
41
42   myMatrix.eM11 = myMatrix.eM22 = 1.0F;
43   myMatrix.eM12 = myMatrix.eM21 = 0.0F;
44   myMatrix.eDx  = myMatrix.eDy  = 0.0F;
45
46   myFlags            &= ~W32F_WIN95;
47 }  // end constructor
48
49 WNT_Allocator :: ~WNT_Allocator ()
50 {
51   DeletePen   ( myLinePen );
52   DeleteBrush ( myPolyBrush );
53   DeletePen   ( myTextPen );
54   DeleteBrush ( myTextBrush );
55   DeletePen   ( myMarkerPen );
56 }  // end destructor
57
58 void WNT_Allocator :: TransformPoint  (int& X, int& Y)
59 {
60   X = int ( myScaleX * ( X - myPivot.x ) );
61   Y = int ( myScaleY * ( Y - myPivot.y ) );
62 } // WNT_Allocator :: TransformPoint
63
64 void WNT_Allocator :: TransformPoint  (LPPOINT lpPoint)
65 {
66   lpPoint->x = int ( myScaleX * ( lpPoint->x - myPivot.x ) );
67   lpPoint->y = int ( myScaleY * ( lpPoint->y - myPivot.y ) );
68 } // WNT_Allocator :: TransformPoint
69
70 #define ADD_POINT_TO_RECT(aPoint) \
71   { if ( aPoint.x < myURect.left   ) myURect.left   = aPoint.x - myLineWidth - 1; \
72     if ( aPoint.x > myURect.right  ) myURect.right  = aPoint.x + myLineWidth + 1; \
73     if ( aPoint.y < myURect.top    ) myURect.top    = aPoint.y - myLineWidth - 1; \
74     if ( aPoint.y > myURect.bottom ) myURect.bottom = aPoint.y + myLineWidth + 1; \
75   }
76
77 void WNT_Allocator :: Register ( int x, int y )
78 {
79   static POINT pt;
80   pt.x = x; pt.y = y;
81   LPtoDP ( myHDC, &pt, 1 );
82   ADD_POINT_TO_RECT (pt);
83 } // WNT_Allocator :: Register
84
85 void WNT_Allocator :: Register ( LPPOINT lpPts, int nPts )
86 {
87   for ( int i = 0; i < nPts; i++ )
88     Register ( lpPts[i].x, lpPts[i].y );
89 } // WNT_Allocator :: Register
90
91 void WNT_Allocator :: Register ( LPRECT lpRect )
92 {
93   Register ( lpRect->left,  lpRect->top    );
94   Register ( lpRect->left,  lpRect->bottom );
95   Register ( lpRect->right, lpRect->top    );
96   Register ( lpRect->right, lpRect->bottom );
97 } // WNT_Allocator :: Register
98
99 void WNT_Allocator :: RecalcMatrix (
100                         XFORM& Matrix, double Angle,
101                         double PivotX, double PivotY
102                       )
103 {
104   float CosA = ( float )cos ( Angle );
105   float SinA = ( float )sin ( Angle );
106   Matrix.eM11 =  float ( CosA );
107   Matrix.eM12 =  float ( SinA );
108   Matrix.eM21 = -float ( SinA );
109   Matrix.eM22 =  float ( CosA );
110   Matrix.eDx  =  float ( PivotX );
111   Matrix.eDy  =  float ( PivotY );
112 }  // end  WNT_Allocator :: RecalcMatrix
113
114 void WNT_Allocator :: Play ( HDC hdc, PSIZE szClient )
115 {
116   CopyMemory ( &mySize, szClient, sizeof ( SIZE ) );
117   if (  !( myFlags & W32F_EMPTY )  ) {
118     POINT pVOExt;
119     SIZE  szWExt, szVExt;
120     int   nMapMode, nGMode, nBkMode;
121
122     myHDC          = hdc;
123     nMapMode       = SetMapMode ( myHDC, MM_ISOTROPIC );
124     SetRect          ( &myURect, mySize.cx, mySize.cy, 0, 0            );
125     SetWindowExtEx   ( myHDC, szClient->cx, -szClient->cy,     &szWExt );
126     SetViewportExtEx ( myHDC, szClient->cx,  szClient->cy,     &szVExt );
127     SetViewportOrgEx ( myHDC, 0,             szClient->cy - 1, &pVOExt );
128     nGMode         = SetGraphicsMode  ( myHDC, GM_ADVANCED );
129     nBkMode        = SetBkMode        ( myHDC, TRANSPARENT );
130     SelectPen        ( myHDC, myLinePen   );
131     SelectBrush      ( myHDC, myPolyBrush );
132     SetTextColor     ( myHDC, myTextColor );
133
134     Xform ();
135     for ( PW32_Block aBlock = myStart; aBlock != NULL; aBlock = aBlock -> next )
136       for ( int i = 0; i < aBlock -> free; i += aBlock -> data[ i ] )
137         if ( aBlock -> data[ i + 1 ] != __W32_DATA ) {
138           W32_Note* pNote = ( W32_Note* )&( aBlock -> data[ i + 1 ] );
139           pNote -> Play ();
140         }  // end if
141
142     SetMapMode       ( myHDC, nMapMode                   );
143     SetWindowExtEx   ( myHDC, szWExt.cx, szWExt.cy, NULL );
144     SetViewportExtEx ( myHDC, szVExt.cx, szVExt.cy, NULL );
145     SetViewportOrgEx ( myHDC, pVOExt.x,  pVOExt.y,  NULL );
146     SetBkMode        ( myHDC, nBkMode                    );
147     SetGraphicsMode  ( myHDC, nGMode                     );
148   }  // end if
149 }  // end WNT_Allocator :: Play
150
151 void WNT_Allocator :: URect ( LPRECT lpRect )
152 {
153   CopyRect ( lpRect, &myURect );
154   if ( lpRect -> top    < 0 )         lpRect -> top    = 0;
155   if ( lpRect -> left   < 0 )         lpRect -> left   = 0;
156   if ( lpRect -> right  > mySize.cx ) lpRect -> right  = mySize.cx;
157   if ( lpRect -> bottom > mySize.cy ) lpRect -> bottom = mySize.cy;
158 }  // end WNT_Allocator :: URect
159
160 void WNT_Allocator :: Xform ( void )
161 {
162   if ( myAngle  != 0.0 || myPivot.x != 0 || myPivot.y != 0 ||
163        myMove.x != 0   || myMove.y  != 0 )
164   {
165     RecalcMatrix         ( myMatrix, myAngle,
166                            myPivot.x + myMove.x,
167                            myPivot.y + myMove.y );
168     SetWorldTransform    ( myHDC, &myMatrix );
169   } else {
170     ModifyWorldTransform ( myHDC, NULL, MWT_IDENTITY );
171   }
172 }  // end WNT_Allocator :: Xform
173
174 void WNT_Allocator :: Point ( int x, int y ) {
175
176  new ( this ) WNT_PointNote ( x, y );
177
178 }  // end WNT_Allocator :: Point
179
180 void WNT_Allocator :: MarkerPoint ( int x, int y ) {
181
182  new ( this ) WNT_MarkerPointNote ( x, y );
183
184 }  // end WNT_Allocator :: MarkerPoint
185
186 void WNT_Allocator :: Line ( int x, int y, int x1, int y1 ) {
187
188  new ( this ) WNT_LineNote ( x, y, x1, y1 );
189
190 }  // end WNT_Allocator :: Line
191
192 void WNT_Allocator :: PolyEllipse ( int xc, int yc, int xr, int yr ) {
193
194  new ( this ) WNT_PolyEllipseNote ( xc, yc, xr, yr );
195
196 }  // end WNT_Allocator :: PolyEllipse
197
198 void WNT_Allocator :: Ellipse ( int xc, int yc, int xr, int yr ) {
199
200  new ( this ) WNT_EllipseNote ( xc, yc, xr, yr );
201
202 }  // end WNT_Allocator :: Ellipse
203
204 void WNT_Allocator :: Arc (
205                        int xc, int yc, int xr, int yr,
206                        double sa, double oa
207                       ) {
208                       
209  new ( this ) WNT_ArcNote ( xc, yc, xr, yr, sa, oa );                      
210                       
211 }  // end WNT_Allocator :: Arc
212
213 void WNT_Allocator :: PolyChord (
214                        int xc, int yc, int xr, int yr,
215                        double sa, double oa
216                       ) {
217                       
218  new ( this ) WNT_PolyChordNote ( xc, yc, xr, yr, sa, oa );
219                       
220 }  // end WNT_Allocator :: PolyChord
221
222 void WNT_Allocator :: Chord (
223                        int xc, int yc, int xr, int yr,
224                        double sa, double oa
225                       ) {
226                       
227  new ( this ) WNT_PolyChordNote ( xc, yc, xr, yr, sa, oa );
228                       
229 }  // end WNT_Allocator :: Chord
230
231 void WNT_Allocator :: PolySector (
232                        int xc, int yc, int xr, int yr,
233                        double sa, double oa
234                       ) {
235                       
236  new ( this ) WNT_PolySectorNote ( xc, yc, xr, yr, sa, oa );
237                       
238 }  // end WNT_Allocator :: PolySector
239
240 void WNT_Allocator :: Sector (
241                        int xc, int yc, int xr, int yr,
242                        double sa, double oa
243                       ) {
244                       
245  new ( this ) WNT_SectorNote ( xc, yc, xr, yr, sa, oa );
246                       
247 }  // end WNT_Allocator :: Sector
248
249 void WNT_Allocator :: PolyMarker ( int aMaxPoints ) {
250
251  new ( this ) W32_PolyMarkerNote ( aMaxPoints );
252
253 }  // end WNT_Allocator :: PolyMarker
254
255 void WNT_Allocator :: PolyMarker1 (
256                        int aMaxPoints, GetPointFunc fn,
257                        int aStartPoint, void* fParam
258                       ) {
259                       
260  new ( this ) WNT_PolyMarker1Note (
261                aMaxPoints, fn, aStartPoint, fParam
262               );
263                       
264 }  // end WNT_Allocator :: PolyMarker1
265
266 void WNT_Allocator :: PolyMarker2 (
267                        int aMaxPoints, GetPointFunc fn,
268                        int aStartPoint, void* fParam
269                       ) {
270   
271  new ( this ) WNT_PolyMarker2Note (
272                aMaxPoints, fn, aStartPoint, fParam
273               );
274                       
275 }  // end WNT_Allocator :: PolyMarker1
276
277 W32_Note* WNT_Allocator :: Polygon ( int aMaxPoints ) {
278
279  return new ( this ) WNT_PolygonNote ( aMaxPoints );
280
281 }  // end WNT_Allocator :: Polygon
282
283 W32_Note* WNT_Allocator :: Polyline ( int aMaxPoints ) {
284
285  return new ( this ) WNT_PolylineNote ( aMaxPoints );
286
287 }  // end WNT_Allocator :: Polyline
288
289 void WNT_Allocator :: Image (
290                        int x, int y, PW32_Bitmap pBmp, double aScale
291                       ) {
292
293  new ( this ) WNT_ImageNote ( x, y, pBmp, aScale );
294
295 }  // end WNT_Allocator :: Image
296
297 void WNT_Allocator :: Text (
298                        int x, int y, double angle, void* text,
299                        BOOL fWide, BOOL fOutlined
300                       ) {
301
302  new ( this ) WNT_TextNote ( x, y, angle, text, fWide, fOutlined );
303
304 }  // end WNT_Allocator :: Text
305
306 void WNT_Allocator :: Polytext (
307                        int x, int y, double angle, double margin,
308                        void* text, BOOL fWide, BOOL fOutlined
309                       ) {
310                       
311  new ( this ) WNT_PolyTextNote ( x, y, angle, margin, text, fWide, fOutlined );
312                       
313 }  // end WNT_Allocator :: Polytext
314
315 void WNT_Allocator :: BeginMarker (
316                        int x, int y, int w, int h, double angle
317                       ) {
318                       
319  new ( this ) WNT_BeginMarkerNote ( x, y, w, h, angle );                      
320                       
321 }  // end WNT_Allocator :: BeginMarker
322
323 void WNT_Allocator :: EndMarker ( void ) {
324
325  new ( this ) WNT_EndMarkerNote ();
326
327 }  // end WNT_Allocator :: EndMarker
328
329 void WNT_Allocator :: LineAttrib (
330                        DWORD width, PLOGBRUSH plb,
331                        DWORD nStyles, PDWORD pdwStyle
332                       ) {
333                       
334  new ( this ) WNT_LineAttribNote ( width, plb, nStyles, pdwStyle );
335                       
336 }  // end WNT_Allocator :: LineAttrib
337
338 void WNT_Allocator :: PolyAttrib (
339                        PLOGBRUSH plb, BOOL fDrawEdge, int aFillMode
340                       ) {
341
342  new ( this ) WNT_PolyAttribNote ( plb, fDrawEdge, aFillMode );
343
344 }  // end WNT_Allocator :: PolyAttrib
345
346 void WNT_Allocator :: TextAttrib (
347                        HFONT hFont, COLORREF color, double slant,
348                        double hScale, double vScale,
349                        BOOL fUnderlined, BOOL fFree, BOOL fIndex
350                       ) {
351  
352  new ( this ) WNT_TextAttribNote (
353                hFont, color, slant, hScale, vScale,
354                fUnderlined, fFree, fIndex
355               );
356
357 }  // end WNT_Allocator :: TextAttrib
358
359 void WNT_Allocator :: MarkerAttrib (
360                        COLORREF color, DWORD dwWidth, BOOL fFill
361                       ) {
362                       
363  new ( this ) WNT_MarkerAttribNote ( color, dwWidth, fFill );                      
364                       
365 }  // end WNT_Allocator :: MarkerAttrib
366
367 void WNT_Allocator :: FunCall (
368                        W32_FCall fCall, int sz, PW32_FCALLPARAM param
369                       ) {
370
371  new ( this ) W32_FCallNote ( fCall, sz, param );
372
373 }  // end WNT_Allocator :: FunCall
374
375 void WNT_Allocator :: GetExtent ( LPSIZE lpSZ )
376 {
377   CopyMemory ( lpSZ, &mySize, sizeof ( SIZE ) );
378 }
379
380 int WNT_Allocator :: TextSize ( HDC hdc, char* str, PSIZE psz ) {
381
382  int      gMode = GetGraphicsMode ( hdc );
383  XFORM    xfm, xfms;
384  POINT    pt;
385  ABC      abcf;
386
387  if ( gMode == GM_ADVANCED )
388   GetWorldTransform ( hdc, &xfms );
389  else
390   SetGraphicsMode ( hdc, GM_ADVANCED );
391
392  ModifyWorldTransform ( hdc, &xfmIdent, MWT_IDENTITY );
393  xfm.eM11 = 1.0F;
394  xfm.eM12 = 0.0F;
395  xfm.eM21 = ( FLOAT )tan ( myTextSlant );
396  xfm.eM22 = 1.0F;
397  xfm.eDx  = 0.0F;
398  xfm.eDy  = 0.0F;
399  ModifyWorldTransform ( hdc, &xfm, MWT_LEFTMULTIPLY );
400  xfm.eM11 = FLOAT ( myTextHScale * myScaleX );
401  xfm.eM12 = 0.0F;
402  xfm.eM21 = 0.0F;
403  xfm.eM22 = FLOAT ( myTextVScale * myScaleY );
404  xfm.eDx  = 0.0F;
405  xfm.eDy  = 0.0F;
406  ModifyWorldTransform ( hdc, &xfm, MWT_LEFTMULTIPLY );
407
408  MoveToEx ( hdc, 0, 0, &pt );
409  GetTextExtentPoint32A (
410   hdc, str, lstrlenA ( str ), psz
411  );
412  GetCharABCWidthsA ( hdc, str[ 0 ], str[ 0 ], &abcf );
413  MoveToEx ( hdc, pt.x, pt.y, NULL );
414
415  if ( gMode == GM_ADVANCED )
416    SetWorldTransform ( hdc, &xfms );
417  else {
418    psz->cx    = LONG ( psz->cx   * xfm.eM11 );
419    psz->cy    = LONG ( psz->cy   * xfm.eM22 );
420    abcf.abcA  = UINT ( abcf.abcA * xfm.eM11 );
421    SetGraphicsMode ( hdc, gMode );
422  }  // end else
423
424  return abcf.abcA;
425 }  // end WNT_Allocator :: TextSize
426   
427 int WNT_Allocator :: TextSize ( HDC hdc, wchar_t* str, PSIZE psz ) {
428
429  int      gMode = GetGraphicsMode ( hdc );
430  XFORM    xfm, xfms;
431  POINT    pt;
432  ABC      abcf;
433
434  if ( gMode == GM_ADVANCED )
435   GetWorldTransform ( hdc, &xfms );
436  else
437   SetGraphicsMode ( hdc, GM_ADVANCED );
438
439  ModifyWorldTransform ( hdc, &xfmIdent, MWT_IDENTITY );
440  xfm.eM11 = 1.0F;
441  xfm.eM12 = 0.0F;
442  xfm.eM21 = ( FLOAT )tan ( myTextSlant );
443  xfm.eM22 = 1.0F;
444  xfm.eDx  = 0.0F;
445  xfm.eDy  = 0.0F;
446  ModifyWorldTransform ( hdc, &xfm, MWT_LEFTMULTIPLY );
447  xfm.eM11 = FLOAT ( myTextHScale * myScaleX );
448  xfm.eM12 = 0.0F;
449  xfm.eM21 = 0.0F;
450  xfm.eM22 = FLOAT ( myTextVScale * myScaleY );
451  xfm.eDx  = 0.0F;
452  xfm.eDy  = 0.0F;
453  ModifyWorldTransform ( hdc, &xfm, MWT_LEFTMULTIPLY );
454
455  MoveToEx ( hdc, 0, 0, &pt );
456  GetTextExtentPoint32W (
457   hdc, str, lstrlenW ( str ), psz
458  );
459  GetCharABCWidthsW ( hdc, str[ 0 ], str[ 0 ], &abcf );
460  MoveToEx ( hdc, pt.x, pt.y, NULL );
461
462  if ( gMode == GM_ADVANCED )
463    SetWorldTransform ( hdc, &xfms );
464  else {
465    psz->cx    = LONG ( psz->cx   * xfm.eM11 );
466    psz->cy    = LONG ( psz->cy   * xfm.eM22 );
467    abcf.abcA  = UINT ( abcf.abcA * xfm.eM11 );
468    SetGraphicsMode ( hdc, gMode );
469  }  // end else
470
471  return abcf.abcA;
472 }  // end WNT_Allocator :: TextSize
473
474 ////////////////////////////////////////////////////////////////////////////////
475 // W N T _ P o i n t N o t e                                                  //
476 ////////////////////////////////////////////////////////////////////////////////
477 WNT_PointNote :: WNT_PointNote ( int x, int y ) :
478                   W32_PointNote ( x, y )
479 {
480 }  // end constructor
481
482 void WNT_PointNote :: Play ( BOOL fDummy )
483 {
484   Xform ();
485   SetPixel  ( ALLOCATOR -> myHDC, myTX, myTY, ALLOCATOR -> myPointColor );
486 }  // end WNT_PointNote :: Play
487
488 void WNT_PointNote :: Xform ()
489 {
490   myTX = myX;
491   myTY = myY;
492   ALLOCATOR -> TransformPoint ( myTX, myTY );
493   ALLOCATOR -> Register       ( myTX, myTY );
494 }
495 ////////////////////////////////////////////////////////////////////////////////
496 // W N T _ M a r k e r P o i n t N o t e                                      //
497 ////////////////////////////////////////////////////////////////////////////////
498 WNT_MarkerPointNote :: WNT_MarkerPointNote ( int x, int y ) :
499                         WNT_PointNote ( x, y )
500 {
501 }  // end constructor
502
503 void WNT_MarkerPointNote :: Play ( BOOL fDummy )
504 {
505   Xform ();
506   SetPixel  ( ALLOCATOR -> myHDC, myTX, myTY, ALLOCATOR -> myMarkerPointColor );
507 }  // end WNT_MarkerPointNote :: Play
508 ////////////////////////////////////////////////////////////////////////////////
509 // W N T _ L i n e N o t e                                                    //
510 ////////////////////////////////////////////////////////////////////////////////
511 WNT_LineNote :: WNT_LineNote ( int x, int y, int x1, int y1 ) :
512                  WNT_PointNote ( x, y )
513 {
514   myX2 = x1;
515   myY2 = y1;
516 }  // end constructor
517
518 void WNT_LineNote :: Play ( BOOL fDummy )
519 {
520   Xform ();
521   MoveToEx                 ( ALLOCATOR -> myHDC, myTX , myTY, NULL    );
522   LineTo                   ( ALLOCATOR -> myHDC, myTX2, myTY2         );
523 }  // end WNT_LineNote :: Play
524
525 void WNT_LineNote :: Xform ()
526 {
527   WNT_PointNote :: Xform ();
528   myTX2 = myX2;
529   myTY2 = myY2;
530   ALLOCATOR -> TransformPoint ( myTX2, myTY2 );
531   ALLOCATOR -> Register       ( myTX2, myTY2 );
532 }
533 ////////////////////////////////////////////////////////////////////////////////
534 // W N T _ P o l y E l l i p s e N o t e                                      //
535 ////////////////////////////////////////////////////////////////////////////////
536 WNT_PolyEllipseNote :: WNT_PolyEllipseNote ( int xc, int yc, int xr, int yr ) :
537                         WNT_PointNote ( xc, yc )
538 {
539   myXr = xr;
540   myYr = yr;
541 }  // end constructor
542
543 void WNT_PolyEllipseNote :: Play ( BOOL fDummy )
544 {
545   Xform ();
546   Ellipse ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
547                                 myTX + myTXr, myTY + myTYr );
548 }  // end WNT_PolyEllipseNote :: Play
549
550 void WNT_PolyEllipseNote :: Xform ()
551 {
552   WNT_PointNote :: Xform ();
553   myTXr = int (myXr * ALLOCATOR -> myScaleX);
554   myTYr = int (myYr * ALLOCATOR -> myScaleY);
555   RECT r = { myTX - myTXr, myTY - myTYr, myTX + myTXr, myTY + myTYr };
556   ALLOCATOR -> Register ( &r );
557 }
558 ////////////////////////////////////////////////////////////////////////////////
559 // W N T _ E l l i p s e N o t e                                              //
560 ////////////////////////////////////////////////////////////////////////////////
561 WNT_EllipseNote :: WNT_EllipseNote ( int xc, int yc, int xr, int yr ) :
562                     WNT_PolyEllipseNote ( xc, yc, xr, yr )
563 {
564 }  // end constructor
565
566 void WNT_EllipseNote :: Play ( BOOL fDummy )
567 {
568   Xform ();
569   HBRUSH hob = SelectBrush ( ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH) );
570   Ellipse     ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
571                                     myTX + myTXr, myTY + myTYr );
572   SelectBrush ( ALLOCATOR -> myHDC, hob );
573 }  // end WNT_PolyEllipseNote :: Play
574 ////////////////////////////////////////////////////////////////////////////////
575 // W N T _ A r c N o t e                                                      //
576 ////////////////////////////////////////////////////////////////////////////////
577 WNT_ArcNote :: WNT_ArcNote (
578                 int xc, int yc, int xr, int yr, double sa, double oa
579                ) : WNT_PolyEllipseNote ( xc, yc, xr, yr )
580 {
581   int    Radius = max ( xr, yr );
582   double sSinA  = sin ( sa + oa );
583   double sCosA  = cos ( sa + oa );
584   double eSinA  = sin ( sa );
585   double eCosA  = cos ( sa );
586   myDirect = ( sa + oa > 0. ) ? AD_COUNTERCLOCKWISE : AD_CLOCKWISE;
587
588   mySX = int ( sCosA * 2 * Radius + xc );
589   mySY = int ( sSinA * 2 * Radius + yc );
590   myEX = int ( eCosA * 2 * Radius + xc );
591   myEY = int ( eSinA * 2 * Radius + yc );
592 }  // end constructor
593
594 void WNT_ArcNote :: Play ( BOOL fDummy )
595 {
596   Xform ();
597   HDC hdc = ALLOCATOR -> myHDC;
598   SetArcDirection ( ALLOCATOR -> myHDC, myDirect );
599   Arc ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
600                             myTX + myTXr, myTY + myTYr,
601                             myTSX, myTSY, myTEX, myTEY );
602 }  // end WNT_ArcNote :: Play
603
604 void WNT_ArcNote :: Xform ()
605 {
606   WNT_PolyEllipseNote :: Xform ();
607   myTSX = mySX;
608   myTSY = mySY;
609   ALLOCATOR -> TransformPoint ( myTSX, myTSY );
610   myTEX = myEX;
611   myTEY = myEY;
612   ALLOCATOR -> TransformPoint ( myTEX, myTEY );
613 }
614 ////////////////////////////////////////////////////////////////////////////////
615 // W N T _ P o l y C h o r d N o t e                                          //
616 ////////////////////////////////////////////////////////////////////////////////
617 WNT_PolyChordNote :: WNT_PolyChordNote (
618                       int xc, int yc, int xr, int yr, double sa, double oa
619                      ) : WNT_ArcNote ( xc, yc, xr, yr, sa, oa )
620 {
621 }  // end constructor
622
623 void WNT_PolyChordNote :: Play ( BOOL fDummy )
624 {
625   Xform ();
626   Chord ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
627                               myTX + myTXr, myTY + myTYr,
628                               myTEX, myTEY, myTSX, myTSY );
629 }  // end WNT_PolyChordNote :: Play
630 ////////////////////////////////////////////////////////////////////////////////
631 // W N T _ C h o r d N o t e                                                  //
632 ////////////////////////////////////////////////////////////////////////////////
633 WNT_ChordNote :: WNT_ChordNote (
634                   int xc, int yc, int xr, int yr, double sa, double oa
635                  ) : WNT_PolyChordNote ( xc, yc, xr, yr, sa, oa )
636 {
637 }  // end constructor
638
639 void WNT_ChordNote :: Play ( BOOL fDummy )
640 {
641   Xform ();
642   HBRUSH hob = SelectBrush ( ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH) );
643   Chord       ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
644                                     myTX + myTXr, myTY + myTYr,
645                                     myTEX, myTEY, myTSX, myTSY );
646   SelectBrush ( ALLOCATOR -> myHDC, hob );
647 }  // end WNT_ChordNote :: Play
648 ////////////////////////////////////////////////////////////////////////////////
649 // W N T _ P o l y S e c t o r N o t e                                        //
650 ////////////////////////////////////////////////////////////////////////////////
651 WNT_PolySectorNote :: WNT_PolySectorNote (
652                       int xc, int yc, int xr, int yr, double sa, double oa
653                      ) : WNT_ArcNote ( xc, yc, xr, yr, sa, oa )
654 {
655 }  // end constructor
656
657 void WNT_PolySectorNote :: Play ( BOOL fDummy )
658 {
659   Xform ();
660   Pie ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
661                             myTX + myTXr, myTY + myTYr,
662                             myTEX, myTEY, myTSX, myTSY );
663 }  // end WNT_PolySectorNote :: Play
664 ////////////////////////////////////////////////////////////////////////////////
665 // W N T _ S e c t o r N o t e                                                //
666 ////////////////////////////////////////////////////////////////////////////////
667 WNT_SectorNote :: WNT_SectorNote (
668                   int xc, int yc, int xr, int yr, double sa, double oa
669                  ) : WNT_PolySectorNote ( xc, yc, xr, yr, sa, oa )
670 {
671 }  // end constructor
672
673 void WNT_SectorNote :: Play ( BOOL fDummy )
674 {
675   Xform ();
676   HBRUSH hob = SelectBrush ( ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH) );
677   Pie         ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr,
678                                     myTX + myTXr, myTY + myTYr,
679                                     myTEX, myTEY, myTSX, myTSY );
680   SelectBrush ( ALLOCATOR -> myHDC, hob );
681 }  // end WNT_SectorNote :: Play
682
683 ////////////////////////////////////////////////////////////////////////////////
684 // D r a w P o l y l i n e                                                    //
685 ////////////////////////////////////////////////////////////////////////////////
686 void DrawPolyline ( HDC hdc, LPPOINT lpPts, int nPts, BOOL fClose )
687 {
688   BeginPath     ( hdc );
689   Polyline      ( hdc, lpPts, nPts );
690   if (fClose)
691     CloseFigure ( hdc );
692   EndPath       ( hdc );
693   StrokePath    ( hdc );
694 }
695 ////////////////////////////////////////////////////////////////////////////////
696 // D r a w P o l y g o n                                                      //
697 ////////////////////////////////////////////////////////////////////////////////
698 void DrawPolygon  ( HDC hdc, LPPOINT lpPts, int nPts, UINT dwFlags )
699 {
700   HPEN hpo = SelectPen ( hdc, GetStockObject ( NULL_PEN ) );
701   Polygon   ( hdc, lpPts, nPts );
702   SelectPen ( hdc, hpo );
703
704   if ( dwFlags & POLYF_NOCLOSEDGE )
705     DrawPolyline ( hdc, lpPts, nPts, FALSE );
706   else if ( !( dwFlags & POLYF_NOEDGE ) )
707     DrawPolyline ( hdc, lpPts, nPts, TRUE  );
708 }
709 ////////////////////////////////////////////////////////////////////////////////
710 // W N T _ P o l y M a r k e r 1 N o t e                                      //
711 ////////////////////////////////////////////////////////////////////////////////
712 WNT_PolyMarker1Note :: WNT_PolyMarker1Note (
713                         int aMaxPoints, GetPointFunc fn, int aStartPoint,
714                         void* fParam
715                        ) : W32_PolyMarker1Note ( aMaxPoints, fn, aStartPoint, fParam)
716 {
717 }  // end constructor
718
719 void WNT_PolyMarker1Note :: Play ( BOOL fDummy )
720 {
721   if ( ALLOCATOR -> myFlags & W32F_MFILL )
722     DrawPolygon  ( ALLOCATOR -> myHDC, myPoints, mySetPoints, POLYF_NOCLOSEDGE );
723   else
724     DrawPolyline ( ALLOCATOR -> myHDC, myPoints, mySetPoints, FALSE );
725 }  // end WNT_PolyMarker1Note :: Play
726 ////////////////////////////////////////////////////////////////////////////////
727 // W N T _ P o l y M a r k e r 2 N o t e                                      //
728 ////////////////////////////////////////////////////////////////////////////////
729 WNT_PolyMarker2Note :: WNT_PolyMarker2Note (
730                         int aMaxPoints, GetPointFunc fn, int aStartPoint,
731                         void* fParam
732                        ) : WNT_PolyMarker1Note (
733                             aMaxPoints, fn, aStartPoint, fParam
734                            )
735 {
736 }  // end constructor
737
738 void WNT_PolyMarker2Note :: Play ( BOOL fDummy )
739 {
740   if ( ALLOCATOR -> myFlags & W32F_MFILL )
741     DrawPolygon  ( ALLOCATOR -> myHDC, myPoints, mySetPoints - 1, 0 );
742   else
743     DrawPolyline ( ALLOCATOR -> myHDC, myPoints, mySetPoints - 1, TRUE );
744 }  // end WNT_PolyMarker2Note :: Play
745 ////////////////////////////////////////////////////////////////////////////////
746 // W N T _ P o l y g o n N o t e                                              //
747 ////////////////////////////////////////////////////////////////////////////////
748 WNT_PolygonNote :: WNT_PolygonNote ( int aMaxPoints ) :
749                     W32_PolygonNote ( aMaxPoints )
750 {
751   myTPoints = ( LPPOINT ) ALLOCATOR -> NewData (myMaxPoints * sizeof ( POINT ));
752 }  // end constructor
753
754 void WNT_PolygonNote :: Play ( BOOL fDummy )
755 {
756   Xform ();
757   DrawPolygon (
758     ALLOCATOR -> myHDC, myTPoints, mySetPoints,
759     ALLOCATOR -> myFlags & W32F_POUTL ? 0 : POLYF_NOEDGE
760   );
761 }  // end WNT_PolygonNote :: Play
762
763 void WNT_PolygonNote :: Xform ()
764 {
765   CopyMemory ( myTPoints, myPoints, mySetPoints*sizeof(POINT) );
766   for ( int i = 0; i < mySetPoints; i++ )
767     ALLOCATOR -> TransformPoint ( (myTPoints + i) );
768   ALLOCATOR -> Register ( myTPoints, mySetPoints );
769 }
770 ////////////////////////////////////////////////////////////////////////////////
771 // W N T _ P o l y l i n e N o t e                                            //
772 ////////////////////////////////////////////////////////////////////////////////
773 WNT_PolylineNote :: WNT_PolylineNote ( int aMaxPoints ) :
774                      WNT_PolygonNote ( aMaxPoints )
775 {
776 }  // end constructor
777
778 void WNT_PolylineNote :: Play ( BOOL fDummy )
779 {
780   Xform ();
781   DWORD nPts;
782   BOOL  fClose;
783   int   idx = mySetPoints - 1;
784   if ( myPoints -> x == myPoints[ idx ].x &&
785        myPoints -> y == myPoints[ idx ].y
786   ) {
787     nPts   = idx;
788     fClose = TRUE;
789   } else {
790     nPts   = mySetPoints;
791     fClose = FALSE;
792   }  // end else
793   DrawPolyline ( ALLOCATOR->myHDC, myTPoints, nPts, fClose );
794 }  // end WNT_PolylineNote :: Play
795 ////////////////////////////////////////////////////////////////////////////////
796 // W N T _ I m a g e N o t e                                                  //
797 ////////////////////////////////////////////////////////////////////////////////
798 WNT_ImageNote :: WNT_ImageNote (
799                   int x, int y, PW32_Bitmap pBmp, double aScale
800                  ) : WNT_PointNote ( x, y )
801 {
802   myBitmap = pBmp;
803   ++pBmp   -> nUsed;
804   myScale  = aScale;
805 }  // end constructor
806
807 WNT_ImageNote :: ~WNT_ImageNote ()
808 {
809   if ( myBitmap -> hBmp != NULL && --myBitmap -> nUsed == 0 ) {
810     DeleteObject ( myBitmap -> hBmp );
811     HeapFree (  GetProcessHeap (), 0, ( PVOID )myBitmap  );
812   }  // end if
813 }  // end WNT_ImageNote :: ~WNT_ImageNote
814
815 void WNT_ImageNote :: Play ( BOOL fDummy )
816 {
817   Xform ();
818   int     xx, yy, w, h;
819   HDC     hdcMem;
820   BITMAP  bmp;
821   HBITMAP hbo;
822
823   GetObject (  myBitmap -> hBmp, sizeof ( BITMAP ), &bmp  );
824   xx = myTX;
825   yy = myTY;
826   w  = bmp.bmWidth;
827   h  = bmp.bmHeight;
828   if ( myScale != 1.0 ) {
829     w  = int (  w * myScale + 0.5 );
830     h  = int (  h * myScale + 0.5 );
831   }
832   if ( ALLOCATOR -> myScaleX != 1.0 ) {
833     xx = int ( xx * ALLOCATOR -> myScaleX + 0.5 );
834     w  = int (  w * ALLOCATOR -> myScaleX + 0.5 );
835   }  // end if
836   if ( ALLOCATOR -> myScaleY != 1.0 ) {
837     yy = int ( yy * ALLOCATOR -> myScaleY + 0.5 );
838     h  = int (  h * ALLOCATOR -> myScaleY + 0.5 );
839   }  // end if
840   xx = xx - ( w >> 1 );
841   yy = yy + ( h >> 1 );
842   hdcMem = CreateCompatibleDC ( ALLOCATOR -> myHDC );
843    hbo   = SelectBitmap ( hdcMem, myBitmap -> hBmp );
844     SetStretchBltMode   ( hdcMem, COLORONCOLOR );
845     StretchBlt (
846       ALLOCATOR -> myHDC,    xx, yy,           w,           -h,
847       hdcMem,                 0,  0, bmp.bmWidth, bmp.bmHeight,
848       SRCCOPY
849     );
850     RECT r = { xx, yy, xx + w, yy - h };
851     ALLOCATOR -> Register ( &r );
852    SelectBitmap ( hdcMem, hbo );
853   DeleteDC      ( hdcMem );
854 }  // end WNT_ImageNote :: Play
855 ////////////////////////////////////////////////////////////////////////////////
856 // W N T _ T e x t N o t e                                                    //
857 ////////////////////////////////////////////////////////////////////////////////
858 #define ROUNDL( d ) ( ( long )( ( d ) + ( ( d ) > 0 ? 0.5 : -0.5 ) ) )
859 WNT_TextNote :: WNT_TextNote (
860                  int x, int y, double angle, void* text,
861                  BOOL fWide, BOOL fOutlined
862                 ) : WNT_PointNote ( x, y )
863 {
864   DWORD dwLen = fWide ? ( ( lstrlenW ( ( LPCWSTR )text ) + 1 ) << 1 )
865                       : ( ( lstrlenA ( ( LPCSTR  )text ) + 1 ) << 0 );
866   myText = ALLOCATOR -> NewData ( dwLen );
867   CopyMemory ( myText, text, dwLen );
868   myFlags = (  ( fWide     ? W32F_TUNICODE : 0 ) |
869                ( fOutlined ? W32F_TOUTLINE : 0 )
870             );
871   ALLOCATOR -> RecalcMatrix ( RMatrix, angle );
872 }  // end constructor
873
874 void WNT_TextNote :: PaintText ()
875 {
876   if (myFlags & W32F_TUNICODE)
877     TextOutW ( ALLOCATOR -> myHDC, 0, myShift, (LPCWSTR)myText, lstrlenW ((LPCWSTR)myText) );
878   else
879     TextOutA ( ALLOCATOR -> myHDC, 0, myShift, (LPCSTR)myText,  lstrlenA ((LPCSTR)myText) );
880 }  // end WNT_TextNote :: PaintText 
881
882 void WNT_TextNote :: SetAttribs ()
883 {
884   ALLOCATOR -> myPO = SelectPen   (ALLOCATOR -> myHDC, ALLOCATOR -> myTextPen  );
885   ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, ALLOCATOR -> myTextBrush);
886   ALLOCATOR -> myFO = SelectFont  (ALLOCATOR -> myHDC, ALLOCATOR -> myTextFont );
887 }  // end WNT_TextNote :: SetAttribs
888
889 void WNT_TextNote :: RestoreAttribs ()
890 {
891   SelectPen   ( ALLOCATOR -> myHDC, ALLOCATOR -> myPO );
892   SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myBO );
893   SelectFont  ( ALLOCATOR -> myHDC, ALLOCATOR -> myFO );
894   ALLOCATOR -> Xform ();
895 }  // end WNT_TextNote :: RestoreAttribs
896
897 void WNT_TextNote :: OutlineText ()
898 {
899   BeginPath  ( ALLOCATOR -> myHDC );
900   PaintText  ( );
901   EndPath    ( ALLOCATOR -> myHDC );
902   StrokePath ( ALLOCATOR -> myHDC );
903 }  // end WNT_TextNote :: OutlineText
904
905 void WNT_TextNote :: FillText ()
906 {
907   PaintText ();
908 }  // end WNT_TextNote :: FillText
909
910 void WNT_TextNote :: Play ( BOOL fDummy )
911 {
912   Xform ();
913   SIZE              size;
914   RECT              rect;
915   HDC               hdc = ALLOCATOR -> myHDC;
916   // Set new world transform and attribs to get text size and metrics
917   SetAttribs ();
918   if ( myFlags & W32F_TUNICODE )
919     ALLOCATOR -> TextSize (  hdc, ( wchar_t* )myText, &size  );
920   else
921     ALLOCATOR -> TextSize (  hdc, ( char* )myText, &size  );
922   ModifyWorldTransform  ( hdc, &RMatrix, MWT_LEFTMULTIPLY );
923   // Register and draw the bounding rect
924   rect.left    =  0;
925   rect.top     =  0;
926   rect.right   =  ROUNDL( ( FLOAT )size.cx * SMatrix.eM11 );
927   rect.bottom  = -ROUNDL( ( FLOAT )size.cy * SMatrix.eM22 );
928   if (ALLOCATOR -> myTextSlant >= 0.F)
929     rect.right  +=  ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 );
930   else
931     rect.left   +=  ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 );
932   ALLOCATOR -> Register ( &rect );
933   // Draw ( fill or outline ) text
934   myShift   = -size.cy;
935   ModifyWorldTransform ( hdc, &IMatrix, MWT_LEFTMULTIPLY );
936   ModifyWorldTransform ( hdc, &SMatrix, MWT_LEFTMULTIPLY );
937   if ( myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO ) OutlineText ();
938   else                                                               FillText    ();
939   RestoreAttribs ();
940 }  // end WNT_TextNote :: Play
941
942 void WNT_TextNote :: Xform ( void )
943 {
944   HDC hdc = ALLOCATOR -> myHDC;
945   WNT_PointNote :: Xform ();
946   RMatrix.eDx  =  float ( myTX ); 
947   RMatrix.eDy  =  float ( myTY );
948   SMatrix.eM11 =  float ( ALLOCATOR -> myTextHScale * ALLOCATOR -> myScaleX );
949   SMatrix.eM12 =  0.0F;
950   SMatrix.eM21 =  0.0F;
951   SMatrix.eM22 = -float ( ALLOCATOR -> myTextVScale * ALLOCATOR -> myScaleY );
952   SMatrix.eDx  =  0.0F;
953   SMatrix.eDy  =  0.0F;
954   IMatrix.eM11 =  1.0F;
955   IMatrix.eM12 =  0.0F;
956   IMatrix.eM21 =  float ( tan (ALLOCATOR -> myTextSlant) );
957   IMatrix.eM22 =  1.0F;
958   IMatrix.eDx  =  0.0F;
959   IMatrix.eDy  =  0.0F;
960 }  // enf WNT_TextNote :: Xform
961 ////////////////////////////////////////////////////////////////////////////////
962 // W N T _ P o l y T e x t N o t e                                            //
963 ////////////////////////////////////////////////////////////////////////////////
964 WNT_PolyTextNote :: WNT_PolyTextNote (
965                      int x, int y, double angle, double margin,
966                      void* text, BOOL fWide, BOOL fOutlined
967                     ) : WNT_TextNote ( x, y, angle, text, fWide, fOutlined ),
968                         myMargin ( margin )
969 {
970 }  // end constructor
971
972 void WNT_PolyTextNote :: Play ( BOOL fDummy )
973 {
974   Xform ();
975   SIZE              size;
976   RECT              rect;
977   int               height;
978   HDC               hdc = ALLOCATOR -> myHDC;
979   // Set new world transform and attribs to get text size and metrics
980   SetAttribs ();
981   if ( myFlags & W32F_TUNICODE )
982     ALLOCATOR -> TextSize (  hdc, ( wchar_t* )myText, &size  );
983   else
984     ALLOCATOR -> TextSize (  hdc, ( char* )myText, &size  );
985   RestoreAttribs ();
986   ModifyWorldTransform  ( hdc, &RMatrix, MWT_LEFTMULTIPLY );
987   // Register and draw the bounding rect
988   rect.left    =  0;
989   rect.top     =  0;
990   rect.right   =  ROUNDL( ( FLOAT )size.cx * SMatrix.eM11 );
991   rect.bottom  = -ROUNDL( ( FLOAT )size.cy * SMatrix.eM22 );
992   if (ALLOCATOR -> myTextSlant >= 0.F)
993     rect.right  +=  ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 );
994   else
995     rect.left   +=  ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 );
996   height = ROUNDL( (FLOAT)rect.bottom * (FLOAT)myMargin / 2.0F );
997   InflateRect ( &rect, height, height );
998   // Drawing round rectangle
999   HPEN   hpo = ( (ALLOCATOR->myFlags & W32F_POUTL) ?
1000                     SelectPen ( hdc, ALLOCATOR -> myLinePen ):
1001                     SelectPen ( hdc, GetStockObject (NULL_PEN) ) );
1002   HBRUSH hbo = ( (ALLOCATOR->myFlags & W32F_NOFIL) ?
1003                     SelectBrush ( hdc, GetStockObject (NULL_BRUSH) ):
1004                     SelectBrush ( hdc, ALLOCATOR -> myPolyBrush ) );
1005   Rectangle    ( hdc, rect.left, rect.top, rect.right, rect.bottom );
1006   SelectBrush  ( hdc, hbo );
1007   SelectPen    ( hdc, hpo );
1008   ALLOCATOR -> Register ( &rect );
1009   // Draw ( fill or outline ) text
1010   myShift   = -size.cy;
1011   ModifyWorldTransform ( hdc, &IMatrix, MWT_LEFTMULTIPLY );
1012   ModifyWorldTransform ( hdc, &SMatrix, MWT_LEFTMULTIPLY );
1013   SetAttribs ();
1014   if (myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO) OutlineText ();
1015   else                                                             FillText    ();
1016   RestoreAttribs ();
1017 }  // end WNT_PolyTextNote :: Play
1018 ////////////////////////////////////////////////////////////////////////////////
1019 // W N T _ B e g i n M a r k e r N o t e                                      //
1020 ////////////////////////////////////////////////////////////////////////////////
1021 WNT_BeginMarkerNote :: WNT_BeginMarkerNote (
1022                         int x, int y, int w, int h, double angle
1023                        ) : WNT_PointNote ( x, y ),
1024                            myAngle ( angle ), myWidth ( w ), myHeight ( h )
1025 {
1026   myPrevAngle = ALLOCATOR -> myAngle;
1027   ALLOCATOR -> RecalcMatrix (myMatrix, myAngle - myPrevAngle, myX, myY);
1028 }  // end constructor
1029
1030 void WNT_BeginMarkerNote :: Play ( BOOL fDummy )
1031 {
1032   ALLOCATOR -> myPO = SelectPen (ALLOCATOR -> myHDC, ALLOCATOR -> myMarkerPen);
1033 #ifdef PRO19042
1034   if ( ALLOCATOR -> myFlags & W32F_MFILL )
1035 #else
1036   if ( ALLOCATOR -> myFlags | W32F_MFILL )
1037 #endif
1038     ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, ALLOCATOR -> myPolyBrush);
1039   else
1040     ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH));
1041   Xform ();
1042 }  // end WNT_BeginMarkerNote :: Play
1043
1044 void WNT_BeginMarkerNote :: Xform ()
1045 {
1046   WNT_PointNote :: Xform ();
1047   if (myPrevAngle != ALLOCATOR -> myAngle) {
1048     myPrevAngle = ALLOCATOR -> myAngle;
1049     ALLOCATOR -> RecalcMatrix (myMatrix, myAngle - myPrevAngle, myX, myY);
1050   }  // end if
1051   myMatrix.eDx = float  ( myTX );
1052   myMatrix.eDy = float  ( myTY );
1053   ModifyWorldTransform  ( ALLOCATOR -> myHDC, &myMatrix, MWT_LEFTMULTIPLY );
1054   RECT r = { -myWidth / 2, -myHeight / 2, myWidth / 2, myHeight / 2 };
1055   ALLOCATOR -> Register ( &r );
1056 }
1057 ////////////////////////////////////////////////////////////////////////////////
1058 // W N T _ E n d M a r k e r N o t e                                          //
1059 ////////////////////////////////////////////////////////////////////////////////
1060 WNT_EndMarkerNote :: WNT_EndMarkerNote ()
1061 {
1062 }
1063
1064 void WNT_EndMarkerNote :: Play ( BOOL fDummy )
1065 {
1066   ALLOCATOR -> Xform ();
1067   SelectPen   ( ALLOCATOR -> myHDC, ALLOCATOR -> myPO );
1068   SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myBO );
1069 }  // end WNT_EndMarkerNote :: Play
1070 ////////////////////////////////////////////////////////////////////////////////
1071 // W N T _ L i n e A t t r i b N o t e                                        //
1072 ////////////////////////////////////////////////////////////////////////////////
1073 WNT_LineAttribNote :: WNT_LineAttribNote (
1074                        DWORD width, PLOGBRUSH plb,
1075                        DWORD nStyles, PDWORD pdwStyle
1076                       )
1077 {
1078   myPointColor = plb -> lbColor;
1079   myWidth      = ((width == 0) ? 1 : width);
1080
1081   if ((width == 0 || width == 1) && (nStyles == 0)) {
1082     myPen = CreatePen (PS_SOLID, width, plb->lbColor);
1083   } else {
1084     DWORD pStyle = ( nStyles > 0 ? PS_USERSTYLE : PS_SOLID );
1085     pStyle |= ( PS_ENDCAP_FLAT | PS_JOIN_MITER | PS_GEOMETRIC );
1086     myPen = ExtCreatePen ( pStyle, width, plb, nStyles, pdwStyle );
1087     if ( !myPen ) {
1088       char err[1024];
1089       DWORD errCode = GetLastError();
1090       printf ( " *** WNT_LineAttribNote : Can't create extended pen: %lu\n", errCode );
1091       wsprintf ( err, "Can't create extended pen: %lu", errCode );
1092       MessageBox ( NULL, err, "WNT_Allocator", MB_OK | MB_ICONEXCLAMATION );
1093       myPen = CreatePen ( PS_SOLID, 1, RGB(170,170,70) );
1094     }
1095   }
1096   Play  ( FALSE );
1097 }  // end constructor
1098
1099 WNT_LineAttribNote :: ~WNT_LineAttribNote ( void )
1100 {
1101 #ifdef PRO19042
1102   if ( myPen ) {
1103 #ifdef DEB
1104 printf(" *** Destroy:WNT_LineAttribNote %x/%x\n",myPen,ALLOCATOR->myLinePen);
1105 #endif
1106     DeletePen( myPen );
1107     myPen = NULL;
1108   }
1109 #else
1110   if ( myPen && myPen != ALLOCATOR -> myLinePen )
1111     DeletePen( myPen );
1112 #endif
1113 }  // enf WNT_LineAttribNote :: ~WNT_LineAttribNote
1114
1115 void WNT_LineAttribNote :: Play ( BOOL fRealize )
1116 {
1117   ALLOCATOR -> myLinePen    = myPen;
1118   ALLOCATOR -> myLineWidth  = myWidth;
1119   ALLOCATOR -> myPointColor = myPointColor;
1120   if ( fRealize )
1121     SelectPen ( ALLOCATOR -> myHDC, myPen );
1122 }  // end WNT_LineAttribNote :: Play
1123 ////////////////////////////////////////////////////////////////////////////////
1124 // W N T _ P o l y A t t r i b N o t e                                        //
1125 ////////////////////////////////////////////////////////////////////////////////
1126 WNT_PolyAttribNote :: WNT_PolyAttribNote (
1127                        PLOGBRUSH plb, BOOL fDrawEdge, int aFillMode
1128                       )
1129 {
1130   myfEdge    = fDrawEdge;
1131   myNoFill   = ( plb -> lbStyle == BS_NULL );
1132   myBrush    = CreateBrushIndirect ( plb );
1133   Play ( FALSE );
1134 }  // end constructor
1135
1136 WNT_PolyAttribNote :: ~WNT_PolyAttribNote ( void )
1137 {
1138 #ifdef PRO19042
1139   if ( myBrush ) {
1140 #ifdef DEB
1141 printf(" *** Destroy:WNT_PolyAttribNote %x/%x\n",myBrush,ALLOCATOR->myPolyBrush);
1142 #endif
1143     DeleteBrush( myBrush );
1144     myBrush = NULL;
1145   }
1146 #else
1147   if ( myBrush && myBrush != ALLOCATOR -> myPolyBrush )
1148     DeleteBrush( myBrush );
1149 #endif
1150 }  // enf WNT_PolyAttribNote :: ~WNT_PolyAttribNote
1151
1152 void WNT_PolyAttribNote :: Play ( BOOL fRealize )
1153 {
1154   if ( myfEdge )  ALLOCATOR -> myFlags |= W32F_POUTL;
1155   else            ALLOCATOR -> myFlags &= ~W32F_POUTL;
1156   if ( myNoFill ) ALLOCATOR -> myFlags |= W32F_NOFIL;
1157   else            ALLOCATOR -> myFlags &= ~W32F_NOFIL;
1158   ALLOCATOR -> myPolyBrush = myBrush;
1159   if ( fRealize ) {
1160     SelectPen   ( ALLOCATOR -> myHDC, ALLOCATOR -> myLinePen   );
1161     SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myPolyBrush );
1162   }
1163 }  // end WNT_PolyAttribNote :: Play
1164 ////////////////////////////////////////////////////////////////////////////////
1165 // W N T _ T e x t A t t r i b N o t e                                        //
1166 ////////////////////////////////////////////////////////////////////////////////
1167 WNT_TextAttribNote :: WNT_TextAttribNote (
1168                        HFONT hFont, COLORREF color, double slant,
1169                        double hScale, double vScale,
1170                        BOOL fUnderlined, BOOL fFree, BOOL fIndex
1171                       )
1172 {
1173   myFont   = hFont;
1174   mySlant  = (slant == 0.0 ? EPS : slant);
1175   myHScale = vScale;
1176   myVScale = hScale;
1177   myFlags  = ( fUnderlined ? W32F_TFULINED : 0 ) |
1178              ( fIndex      ? W32F_TINDEX   : 0 ) |
1179              ( fFree       ? W32F_TFREE    : 0 );
1180   myColor  = color;
1181   myPen    = CreatePen        ( PS_SOLID, 0, color );
1182   myBrush  = CreateSolidBrush ( color );
1183   Play ( FALSE );
1184 }  // end constructor
1185
1186 WNT_TextAttribNote :: ~WNT_TextAttribNote ()
1187 {
1188 #ifdef PRO19042
1189   if ( myFont && (myFlags & W32F_TFREE) ) {
1190 #ifdef DEB
1191 printf(" *** Destroy:WNT_TextAttribNote_FONT %x/%x\n",myFont,ALLOCATOR->myTextFont);
1192 #endif
1193     DeleteFont  ( myFont  );
1194     myFont = NULL;
1195   }
1196   if ( myPen ) {
1197 #ifdef DEB
1198 printf(" *** Destroy:WNT_TextAttribNote_PEN %x/%x\n",myPen,ALLOCATOR->myTextPen);
1199 #endif
1200     DeletePen   ( myPen   );
1201     myPen = NULL;
1202   }
1203   if ( myBrush ) {
1204 #ifdef DEB
1205 printf(" *** Destroy:WNT_TextAttribNote_BRUSH %x/%x\n",myBrush,ALLOCATOR->myTextBrush);
1206 #endif
1207     DeleteBrush ( myBrush );
1208     myBrush = NULL;
1209   }
1210 #else
1211   if ( myFlags & W32F_TFREE )                            DeleteFont  ( myFont  );
1212   if ( myPen   && myPen   != ALLOCATOR -> myTextPen   )  DeletePen   ( myPen   );
1213   if ( myBrush && myBrush != ALLOCATOR -> myTextBrush )  DeleteBrush ( myBrush );
1214 #endif
1215 }  // end destructor
1216
1217 void WNT_TextAttribNote :: Play ( BOOL fRealize )
1218 {
1219   if ( ( ALLOCATOR -> myFlags & W32F_DFONT ) && !( myFlags & W32F_TINDEX ) ) {
1220     DeleteFont( ALLOCATOR -> myTextFont );
1221     ALLOCATOR -> myFlags &= ~W32F_DFONT;
1222   }  // end if
1223   ALLOCATOR -> myTextFont   = myFont;
1224   ALLOCATOR -> myTextSlant  = mySlant;
1225   ALLOCATOR -> myTextHScale = myHScale;
1226   ALLOCATOR -> myTextVScale = myVScale;
1227   ALLOCATOR -> myTextColor  = myColor;
1228   ALLOCATOR -> myTextPen    = myPen;
1229   ALLOCATOR -> myTextBrush  = myBrush;
1230   if (myFlags & W32F_TFULINED) ALLOCATOR -> myFlags |= W32F_TULIN;
1231   else                         ALLOCATOR -> myFlags &= ~W32F_TULIN;
1232   if ( fRealize && !( myFlags & W32F_TINDEX ) ) {
1233     SetTextColor ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextColor );
1234     SelectPen    ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextPen   );
1235     SelectBrush  ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextBrush );
1236     SelectFont   ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextFont  );
1237   }
1238 }  // end WNT_TextAttribNote :: Play
1239 ////////////////////////////////////////////////////////////////////////////////
1240 // W N T _ M a r k e r A t t r i b N o t e                                    //
1241 ////////////////////////////////////////////////////////////////////////////////
1242 WNT_MarkerAttribNote :: WNT_MarkerAttribNote (
1243                          COLORREF color, DWORD dwWidth, BOOL fFill
1244                         )
1245 {
1246   DWORD width = (dwWidth == 0) ? 1 : dwWidth;
1247
1248   myFill             = fFill;
1249   myMarkerPointColor = color;
1250   myPen              = CreatePen ( PS_SOLID, width, color );
1251   Play ();
1252 }  // end constructor
1253
1254 WNT_MarkerAttribNote :: ~WNT_MarkerAttribNote ( void )
1255 {
1256 #ifdef PRO19042
1257   if ( myPen ) {
1258 #ifdef DEB
1259 printf(" *** Destroy:WNT_MarkerAttribNote %x/%x\n",myPen,ALLOCATOR->myMarkerPen);
1260 #endif
1261     DeletePen( myPen );
1262     myPen = NULL;
1263   }
1264 #else
1265   if ( myPen && myPen != ALLOCATOR -> myMarkerPen ) DeletePen( myPen );
1266 #endif
1267 }  // enf WNT_MarkerAttribNote :: ~WNT_MarkerAttribNote
1268
1269 void WNT_MarkerAttribNote :: Play ( BOOL fRealize )
1270 {
1271   if (myFill)  ALLOCATOR -> myFlags |= W32F_MFILL;
1272   else         ALLOCATOR -> myFlags &= ~W32F_MFILL;
1273
1274   ALLOCATOR -> myMarkerPen           = myPen;
1275   ALLOCATOR -> myMarkerPointColor    = myMarkerPointColor;
1276 }  // end WNT_MarkerAttribNote :: Play