7fd59977 |
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 (); |
7fd59977 |
597 | SetArcDirection ( ALLOCATOR -> myHDC, myDirect ); |
598 | Arc ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr, |
599 | myTX + myTXr, myTY + myTYr, |
600 | myTSX, myTSY, myTEX, myTEY ); |
601 | } // end WNT_ArcNote :: Play |
602 | |
603 | void WNT_ArcNote :: Xform () |
604 | { |
605 | WNT_PolyEllipseNote :: Xform (); |
606 | myTSX = mySX; |
607 | myTSY = mySY; |
608 | ALLOCATOR -> TransformPoint ( myTSX, myTSY ); |
609 | myTEX = myEX; |
610 | myTEY = myEY; |
611 | ALLOCATOR -> TransformPoint ( myTEX, myTEY ); |
612 | } |
613 | //////////////////////////////////////////////////////////////////////////////// |
614 | // W N T _ P o l y C h o r d N o t e // |
615 | //////////////////////////////////////////////////////////////////////////////// |
616 | WNT_PolyChordNote :: WNT_PolyChordNote ( |
617 | int xc, int yc, int xr, int yr, double sa, double oa |
618 | ) : WNT_ArcNote ( xc, yc, xr, yr, sa, oa ) |
619 | { |
620 | } // end constructor |
621 | |
622 | void WNT_PolyChordNote :: Play ( BOOL fDummy ) |
623 | { |
624 | Xform (); |
625 | Chord ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr, |
626 | myTX + myTXr, myTY + myTYr, |
627 | myTEX, myTEY, myTSX, myTSY ); |
628 | } // end WNT_PolyChordNote :: Play |
629 | //////////////////////////////////////////////////////////////////////////////// |
630 | // W N T _ C h o r d N o t e // |
631 | //////////////////////////////////////////////////////////////////////////////// |
632 | WNT_ChordNote :: WNT_ChordNote ( |
633 | int xc, int yc, int xr, int yr, double sa, double oa |
634 | ) : WNT_PolyChordNote ( xc, yc, xr, yr, sa, oa ) |
635 | { |
636 | } // end constructor |
637 | |
638 | void WNT_ChordNote :: Play ( BOOL fDummy ) |
639 | { |
640 | Xform (); |
641 | HBRUSH hob = SelectBrush ( ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH) ); |
642 | Chord ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr, |
643 | myTX + myTXr, myTY + myTYr, |
644 | myTEX, myTEY, myTSX, myTSY ); |
645 | SelectBrush ( ALLOCATOR -> myHDC, hob ); |
646 | } // end WNT_ChordNote :: Play |
647 | //////////////////////////////////////////////////////////////////////////////// |
648 | // W N T _ P o l y S e c t o r N o t e // |
649 | //////////////////////////////////////////////////////////////////////////////// |
650 | WNT_PolySectorNote :: WNT_PolySectorNote ( |
651 | int xc, int yc, int xr, int yr, double sa, double oa |
652 | ) : WNT_ArcNote ( xc, yc, xr, yr, sa, oa ) |
653 | { |
654 | } // end constructor |
655 | |
656 | void WNT_PolySectorNote :: Play ( BOOL fDummy ) |
657 | { |
658 | Xform (); |
659 | Pie ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr, |
660 | myTX + myTXr, myTY + myTYr, |
661 | myTEX, myTEY, myTSX, myTSY ); |
662 | } // end WNT_PolySectorNote :: Play |
663 | //////////////////////////////////////////////////////////////////////////////// |
664 | // W N T _ S e c t o r N o t e // |
665 | //////////////////////////////////////////////////////////////////////////////// |
666 | WNT_SectorNote :: WNT_SectorNote ( |
667 | int xc, int yc, int xr, int yr, double sa, double oa |
668 | ) : WNT_PolySectorNote ( xc, yc, xr, yr, sa, oa ) |
669 | { |
670 | } // end constructor |
671 | |
672 | void WNT_SectorNote :: Play ( BOOL fDummy ) |
673 | { |
674 | Xform (); |
675 | HBRUSH hob = SelectBrush ( ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH) ); |
676 | Pie ( ALLOCATOR -> myHDC, myTX - myTXr, myTY - myTYr, |
677 | myTX + myTXr, myTY + myTYr, |
678 | myTEX, myTEY, myTSX, myTSY ); |
679 | SelectBrush ( ALLOCATOR -> myHDC, hob ); |
680 | } // end WNT_SectorNote :: Play |
681 | |
682 | //////////////////////////////////////////////////////////////////////////////// |
683 | // D r a w P o l y l i n e // |
684 | //////////////////////////////////////////////////////////////////////////////// |
685 | void DrawPolyline ( HDC hdc, LPPOINT lpPts, int nPts, BOOL fClose ) |
686 | { |
687 | BeginPath ( hdc ); |
688 | Polyline ( hdc, lpPts, nPts ); |
689 | if (fClose) |
690 | CloseFigure ( hdc ); |
691 | EndPath ( hdc ); |
692 | StrokePath ( hdc ); |
693 | } |
694 | //////////////////////////////////////////////////////////////////////////////// |
695 | // D r a w P o l y g o n // |
696 | //////////////////////////////////////////////////////////////////////////////// |
697 | void DrawPolygon ( HDC hdc, LPPOINT lpPts, int nPts, UINT dwFlags ) |
698 | { |
699 | HPEN hpo = SelectPen ( hdc, GetStockObject ( NULL_PEN ) ); |
700 | Polygon ( hdc, lpPts, nPts ); |
701 | SelectPen ( hdc, hpo ); |
702 | |
703 | if ( dwFlags & POLYF_NOCLOSEDGE ) |
704 | DrawPolyline ( hdc, lpPts, nPts, FALSE ); |
705 | else if ( !( dwFlags & POLYF_NOEDGE ) ) |
706 | DrawPolyline ( hdc, lpPts, nPts, TRUE ); |
707 | } |
708 | //////////////////////////////////////////////////////////////////////////////// |
709 | // W N T _ P o l y M a r k e r 1 N o t e // |
710 | //////////////////////////////////////////////////////////////////////////////// |
711 | WNT_PolyMarker1Note :: WNT_PolyMarker1Note ( |
712 | int aMaxPoints, GetPointFunc fn, int aStartPoint, |
713 | void* fParam |
714 | ) : W32_PolyMarker1Note ( aMaxPoints, fn, aStartPoint, fParam) |
715 | { |
716 | } // end constructor |
717 | |
718 | void WNT_PolyMarker1Note :: Play ( BOOL fDummy ) |
719 | { |
720 | if ( ALLOCATOR -> myFlags & W32F_MFILL ) |
721 | DrawPolygon ( ALLOCATOR -> myHDC, myPoints, mySetPoints, POLYF_NOCLOSEDGE ); |
722 | else |
723 | DrawPolyline ( ALLOCATOR -> myHDC, myPoints, mySetPoints, FALSE ); |
724 | } // end WNT_PolyMarker1Note :: Play |
725 | //////////////////////////////////////////////////////////////////////////////// |
726 | // W N T _ P o l y M a r k e r 2 N o t e // |
727 | //////////////////////////////////////////////////////////////////////////////// |
728 | WNT_PolyMarker2Note :: WNT_PolyMarker2Note ( |
729 | int aMaxPoints, GetPointFunc fn, int aStartPoint, |
730 | void* fParam |
731 | ) : WNT_PolyMarker1Note ( |
732 | aMaxPoints, fn, aStartPoint, fParam |
733 | ) |
734 | { |
735 | } // end constructor |
736 | |
737 | void WNT_PolyMarker2Note :: Play ( BOOL fDummy ) |
738 | { |
739 | if ( ALLOCATOR -> myFlags & W32F_MFILL ) |
740 | DrawPolygon ( ALLOCATOR -> myHDC, myPoints, mySetPoints - 1, 0 ); |
741 | else |
742 | DrawPolyline ( ALLOCATOR -> myHDC, myPoints, mySetPoints - 1, TRUE ); |
743 | } // end WNT_PolyMarker2Note :: Play |
744 | //////////////////////////////////////////////////////////////////////////////// |
745 | // W N T _ P o l y g o n N o t e // |
746 | //////////////////////////////////////////////////////////////////////////////// |
747 | WNT_PolygonNote :: WNT_PolygonNote ( int aMaxPoints ) : |
748 | W32_PolygonNote ( aMaxPoints ) |
749 | { |
750 | myTPoints = ( LPPOINT ) ALLOCATOR -> NewData (myMaxPoints * sizeof ( POINT )); |
751 | } // end constructor |
752 | |
753 | void WNT_PolygonNote :: Play ( BOOL fDummy ) |
754 | { |
755 | Xform (); |
756 | DrawPolygon ( |
757 | ALLOCATOR -> myHDC, myTPoints, mySetPoints, |
758 | ALLOCATOR -> myFlags & W32F_POUTL ? 0 : POLYF_NOEDGE |
759 | ); |
760 | } // end WNT_PolygonNote :: Play |
761 | |
762 | void WNT_PolygonNote :: Xform () |
763 | { |
764 | CopyMemory ( myTPoints, myPoints, mySetPoints*sizeof(POINT) ); |
765 | for ( int i = 0; i < mySetPoints; i++ ) |
766 | ALLOCATOR -> TransformPoint ( (myTPoints + i) ); |
767 | ALLOCATOR -> Register ( myTPoints, mySetPoints ); |
768 | } |
769 | //////////////////////////////////////////////////////////////////////////////// |
770 | // W N T _ P o l y l i n e N o t e // |
771 | //////////////////////////////////////////////////////////////////////////////// |
772 | WNT_PolylineNote :: WNT_PolylineNote ( int aMaxPoints ) : |
773 | WNT_PolygonNote ( aMaxPoints ) |
774 | { |
775 | } // end constructor |
776 | |
777 | void WNT_PolylineNote :: Play ( BOOL fDummy ) |
778 | { |
779 | Xform (); |
780 | DWORD nPts; |
781 | BOOL fClose; |
782 | int idx = mySetPoints - 1; |
783 | if ( myPoints -> x == myPoints[ idx ].x && |
784 | myPoints -> y == myPoints[ idx ].y |
785 | ) { |
786 | nPts = idx; |
787 | fClose = TRUE; |
788 | } else { |
789 | nPts = mySetPoints; |
790 | fClose = FALSE; |
791 | } // end else |
792 | DrawPolyline ( ALLOCATOR->myHDC, myTPoints, nPts, fClose ); |
793 | } // end WNT_PolylineNote :: Play |
794 | //////////////////////////////////////////////////////////////////////////////// |
795 | // W N T _ I m a g e N o t e // |
796 | //////////////////////////////////////////////////////////////////////////////// |
797 | WNT_ImageNote :: WNT_ImageNote ( |
798 | int x, int y, PW32_Bitmap pBmp, double aScale |
799 | ) : WNT_PointNote ( x, y ) |
800 | { |
801 | myBitmap = pBmp; |
802 | ++pBmp -> nUsed; |
803 | myScale = aScale; |
804 | } // end constructor |
805 | |
806 | WNT_ImageNote :: ~WNT_ImageNote () |
807 | { |
808 | if ( myBitmap -> hBmp != NULL && --myBitmap -> nUsed == 0 ) { |
809 | DeleteObject ( myBitmap -> hBmp ); |
810 | HeapFree ( GetProcessHeap (), 0, ( PVOID )myBitmap ); |
811 | } // end if |
812 | } // end WNT_ImageNote :: ~WNT_ImageNote |
813 | |
814 | void WNT_ImageNote :: Play ( BOOL fDummy ) |
815 | { |
816 | Xform (); |
817 | int xx, yy, w, h; |
818 | HDC hdcMem; |
819 | BITMAP bmp; |
820 | HBITMAP hbo; |
821 | |
822 | GetObject ( myBitmap -> hBmp, sizeof ( BITMAP ), &bmp ); |
823 | xx = myTX; |
824 | yy = myTY; |
825 | w = bmp.bmWidth; |
826 | h = bmp.bmHeight; |
827 | if ( myScale != 1.0 ) { |
828 | w = int ( w * myScale + 0.5 ); |
829 | h = int ( h * myScale + 0.5 ); |
830 | } |
831 | if ( ALLOCATOR -> myScaleX != 1.0 ) { |
832 | xx = int ( xx * ALLOCATOR -> myScaleX + 0.5 ); |
833 | w = int ( w * ALLOCATOR -> myScaleX + 0.5 ); |
834 | } // end if |
835 | if ( ALLOCATOR -> myScaleY != 1.0 ) { |
836 | yy = int ( yy * ALLOCATOR -> myScaleY + 0.5 ); |
837 | h = int ( h * ALLOCATOR -> myScaleY + 0.5 ); |
838 | } // end if |
839 | xx = xx - ( w >> 1 ); |
840 | yy = yy + ( h >> 1 ); |
841 | hdcMem = CreateCompatibleDC ( ALLOCATOR -> myHDC ); |
842 | hbo = SelectBitmap ( hdcMem, myBitmap -> hBmp ); |
843 | SetStretchBltMode ( hdcMem, COLORONCOLOR ); |
844 | StretchBlt ( |
845 | ALLOCATOR -> myHDC, xx, yy, w, -h, |
846 | hdcMem, 0, 0, bmp.bmWidth, bmp.bmHeight, |
847 | SRCCOPY |
848 | ); |
849 | RECT r = { xx, yy, xx + w, yy - h }; |
850 | ALLOCATOR -> Register ( &r ); |
851 | SelectBitmap ( hdcMem, hbo ); |
852 | DeleteDC ( hdcMem ); |
853 | } // end WNT_ImageNote :: Play |
854 | //////////////////////////////////////////////////////////////////////////////// |
855 | // W N T _ T e x t N o t e // |
856 | //////////////////////////////////////////////////////////////////////////////// |
857 | #define ROUNDL( d ) ( ( long )( ( d ) + ( ( d ) > 0 ? 0.5 : -0.5 ) ) ) |
858 | WNT_TextNote :: WNT_TextNote ( |
859 | int x, int y, double angle, void* text, |
860 | BOOL fWide, BOOL fOutlined |
861 | ) : WNT_PointNote ( x, y ) |
862 | { |
863 | DWORD dwLen = fWide ? ( ( lstrlenW ( ( LPCWSTR )text ) + 1 ) << 1 ) |
864 | : ( ( lstrlenA ( ( LPCSTR )text ) + 1 ) << 0 ); |
865 | myText = ALLOCATOR -> NewData ( dwLen ); |
866 | CopyMemory ( myText, text, dwLen ); |
867 | myFlags = ( ( fWide ? W32F_TUNICODE : 0 ) | |
868 | ( fOutlined ? W32F_TOUTLINE : 0 ) |
869 | ); |
870 | ALLOCATOR -> RecalcMatrix ( RMatrix, angle ); |
871 | } // end constructor |
872 | |
873 | void WNT_TextNote :: PaintText () |
874 | { |
875 | if (myFlags & W32F_TUNICODE) |
876 | TextOutW ( ALLOCATOR -> myHDC, 0, myShift, (LPCWSTR)myText, lstrlenW ((LPCWSTR)myText) ); |
877 | else |
878 | TextOutA ( ALLOCATOR -> myHDC, 0, myShift, (LPCSTR)myText, lstrlenA ((LPCSTR)myText) ); |
879 | } // end WNT_TextNote :: PaintText |
880 | |
881 | void WNT_TextNote :: SetAttribs () |
882 | { |
883 | ALLOCATOR -> myPO = SelectPen (ALLOCATOR -> myHDC, ALLOCATOR -> myTextPen ); |
884 | ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, ALLOCATOR -> myTextBrush); |
885 | ALLOCATOR -> myFO = SelectFont (ALLOCATOR -> myHDC, ALLOCATOR -> myTextFont ); |
886 | } // end WNT_TextNote :: SetAttribs |
887 | |
888 | void WNT_TextNote :: RestoreAttribs () |
889 | { |
890 | SelectPen ( ALLOCATOR -> myHDC, ALLOCATOR -> myPO ); |
891 | SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myBO ); |
892 | SelectFont ( ALLOCATOR -> myHDC, ALLOCATOR -> myFO ); |
893 | ALLOCATOR -> Xform (); |
894 | } // end WNT_TextNote :: RestoreAttribs |
895 | |
896 | void WNT_TextNote :: OutlineText () |
897 | { |
898 | BeginPath ( ALLOCATOR -> myHDC ); |
899 | PaintText ( ); |
900 | EndPath ( ALLOCATOR -> myHDC ); |
901 | StrokePath ( ALLOCATOR -> myHDC ); |
902 | } // end WNT_TextNote :: OutlineText |
903 | |
904 | void WNT_TextNote :: FillText () |
905 | { |
906 | PaintText (); |
907 | } // end WNT_TextNote :: FillText |
908 | |
909 | void WNT_TextNote :: Play ( BOOL fDummy ) |
910 | { |
911 | Xform (); |
912 | SIZE size; |
913 | RECT rect; |
914 | HDC hdc = ALLOCATOR -> myHDC; |
915 | // Set new world transform and attribs to get text size and metrics |
916 | SetAttribs (); |
917 | if ( myFlags & W32F_TUNICODE ) |
918 | ALLOCATOR -> TextSize ( hdc, ( wchar_t* )myText, &size ); |
919 | else |
920 | ALLOCATOR -> TextSize ( hdc, ( char* )myText, &size ); |
921 | ModifyWorldTransform ( hdc, &RMatrix, MWT_LEFTMULTIPLY ); |
922 | // Register and draw the bounding rect |
923 | rect.left = 0; |
924 | rect.top = 0; |
925 | rect.right = ROUNDL( ( FLOAT )size.cx * SMatrix.eM11 ); |
926 | rect.bottom = -ROUNDL( ( FLOAT )size.cy * SMatrix.eM22 ); |
927 | if (ALLOCATOR -> myTextSlant >= 0.F) |
928 | rect.right += ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 ); |
929 | else |
930 | rect.left += ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 ); |
931 | ALLOCATOR -> Register ( &rect ); |
932 | // Draw ( fill or outline ) text |
933 | myShift = -size.cy; |
934 | ModifyWorldTransform ( hdc, &IMatrix, MWT_LEFTMULTIPLY ); |
935 | ModifyWorldTransform ( hdc, &SMatrix, MWT_LEFTMULTIPLY ); |
936 | if ( myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO ) OutlineText (); |
937 | else FillText (); |
938 | RestoreAttribs (); |
939 | } // end WNT_TextNote :: Play |
940 | |
941 | void WNT_TextNote :: Xform ( void ) |
942 | { |
7fd59977 |
943 | WNT_PointNote :: Xform (); |
944 | RMatrix.eDx = float ( myTX ); |
945 | RMatrix.eDy = float ( myTY ); |
946 | SMatrix.eM11 = float ( ALLOCATOR -> myTextHScale * ALLOCATOR -> myScaleX ); |
947 | SMatrix.eM12 = 0.0F; |
948 | SMatrix.eM21 = 0.0F; |
949 | SMatrix.eM22 = -float ( ALLOCATOR -> myTextVScale * ALLOCATOR -> myScaleY ); |
950 | SMatrix.eDx = 0.0F; |
951 | SMatrix.eDy = 0.0F; |
952 | IMatrix.eM11 = 1.0F; |
953 | IMatrix.eM12 = 0.0F; |
954 | IMatrix.eM21 = float ( tan (ALLOCATOR -> myTextSlant) ); |
955 | IMatrix.eM22 = 1.0F; |
956 | IMatrix.eDx = 0.0F; |
957 | IMatrix.eDy = 0.0F; |
958 | } // enf WNT_TextNote :: Xform |
959 | //////////////////////////////////////////////////////////////////////////////// |
960 | // W N T _ P o l y T e x t N o t e // |
961 | //////////////////////////////////////////////////////////////////////////////// |
962 | WNT_PolyTextNote :: WNT_PolyTextNote ( |
963 | int x, int y, double angle, double margin, |
964 | void* text, BOOL fWide, BOOL fOutlined |
965 | ) : WNT_TextNote ( x, y, angle, text, fWide, fOutlined ), |
966 | myMargin ( margin ) |
967 | { |
968 | } // end constructor |
969 | |
970 | void WNT_PolyTextNote :: Play ( BOOL fDummy ) |
971 | { |
972 | Xform (); |
973 | SIZE size; |
974 | RECT rect; |
975 | int height; |
976 | HDC hdc = ALLOCATOR -> myHDC; |
977 | // Set new world transform and attribs to get text size and metrics |
978 | SetAttribs (); |
979 | if ( myFlags & W32F_TUNICODE ) |
980 | ALLOCATOR -> TextSize ( hdc, ( wchar_t* )myText, &size ); |
981 | else |
982 | ALLOCATOR -> TextSize ( hdc, ( char* )myText, &size ); |
983 | RestoreAttribs (); |
984 | ModifyWorldTransform ( hdc, &RMatrix, MWT_LEFTMULTIPLY ); |
985 | // Register and draw the bounding rect |
986 | rect.left = 0; |
987 | rect.top = 0; |
988 | rect.right = ROUNDL( ( FLOAT )size.cx * SMatrix.eM11 ); |
989 | rect.bottom = -ROUNDL( ( FLOAT )size.cy * SMatrix.eM22 ); |
990 | if (ALLOCATOR -> myTextSlant >= 0.F) |
991 | rect.right += ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 ); |
992 | else |
993 | rect.left += ROUNDL( ( FLOAT )rect.bottom * IMatrix.eM21 ); |
994 | height = ROUNDL( (FLOAT)rect.bottom * (FLOAT)myMargin / 2.0F ); |
995 | InflateRect ( &rect, height, height ); |
996 | // Drawing round rectangle |
997 | HPEN hpo = ( (ALLOCATOR->myFlags & W32F_POUTL) ? |
998 | SelectPen ( hdc, ALLOCATOR -> myLinePen ): |
999 | SelectPen ( hdc, GetStockObject (NULL_PEN) ) ); |
1000 | HBRUSH hbo = ( (ALLOCATOR->myFlags & W32F_NOFIL) ? |
1001 | SelectBrush ( hdc, GetStockObject (NULL_BRUSH) ): |
1002 | SelectBrush ( hdc, ALLOCATOR -> myPolyBrush ) ); |
1003 | Rectangle ( hdc, rect.left, rect.top, rect.right, rect.bottom ); |
1004 | SelectBrush ( hdc, hbo ); |
1005 | SelectPen ( hdc, hpo ); |
1006 | ALLOCATOR -> Register ( &rect ); |
1007 | // Draw ( fill or outline ) text |
1008 | myShift = -size.cy; |
1009 | ModifyWorldTransform ( hdc, &IMatrix, MWT_LEFTMULTIPLY ); |
1010 | ModifyWorldTransform ( hdc, &SMatrix, MWT_LEFTMULTIPLY ); |
1011 | SetAttribs (); |
1012 | if (myFlags & W32F_TOUTLINE || ALLOCATOR -> myFlags & W32F_MONO) OutlineText (); |
1013 | else FillText (); |
1014 | RestoreAttribs (); |
1015 | } // end WNT_PolyTextNote :: Play |
1016 | //////////////////////////////////////////////////////////////////////////////// |
1017 | // W N T _ B e g i n M a r k e r N o t e // |
1018 | //////////////////////////////////////////////////////////////////////////////// |
1019 | WNT_BeginMarkerNote :: WNT_BeginMarkerNote ( |
1020 | int x, int y, int w, int h, double angle |
1021 | ) : WNT_PointNote ( x, y ), |
1022 | myAngle ( angle ), myWidth ( w ), myHeight ( h ) |
1023 | { |
1024 | myPrevAngle = ALLOCATOR -> myAngle; |
1025 | ALLOCATOR -> RecalcMatrix (myMatrix, myAngle - myPrevAngle, myX, myY); |
1026 | } // end constructor |
1027 | |
1028 | void WNT_BeginMarkerNote :: Play ( BOOL fDummy ) |
1029 | { |
1030 | ALLOCATOR -> myPO = SelectPen (ALLOCATOR -> myHDC, ALLOCATOR -> myMarkerPen); |
1031 | #ifdef PRO19042 |
1032 | if ( ALLOCATOR -> myFlags & W32F_MFILL ) |
1033 | #else |
1034 | if ( ALLOCATOR -> myFlags | W32F_MFILL ) |
1035 | #endif |
1036 | ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, ALLOCATOR -> myPolyBrush); |
1037 | else |
1038 | ALLOCATOR -> myBO = SelectBrush (ALLOCATOR -> myHDC, GetStockObject (NULL_BRUSH)); |
1039 | Xform (); |
1040 | } // end WNT_BeginMarkerNote :: Play |
1041 | |
1042 | void WNT_BeginMarkerNote :: Xform () |
1043 | { |
1044 | WNT_PointNote :: Xform (); |
1045 | if (myPrevAngle != ALLOCATOR -> myAngle) { |
1046 | myPrevAngle = ALLOCATOR -> myAngle; |
1047 | ALLOCATOR -> RecalcMatrix (myMatrix, myAngle - myPrevAngle, myX, myY); |
1048 | } // end if |
1049 | myMatrix.eDx = float ( myTX ); |
1050 | myMatrix.eDy = float ( myTY ); |
1051 | ModifyWorldTransform ( ALLOCATOR -> myHDC, &myMatrix, MWT_LEFTMULTIPLY ); |
1052 | RECT r = { -myWidth / 2, -myHeight / 2, myWidth / 2, myHeight / 2 }; |
1053 | ALLOCATOR -> Register ( &r ); |
1054 | } |
1055 | //////////////////////////////////////////////////////////////////////////////// |
1056 | // W N T _ E n d M a r k e r N o t e // |
1057 | //////////////////////////////////////////////////////////////////////////////// |
1058 | WNT_EndMarkerNote :: WNT_EndMarkerNote () |
1059 | { |
1060 | } |
1061 | |
1062 | void WNT_EndMarkerNote :: Play ( BOOL fDummy ) |
1063 | { |
1064 | ALLOCATOR -> Xform (); |
1065 | SelectPen ( ALLOCATOR -> myHDC, ALLOCATOR -> myPO ); |
1066 | SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myBO ); |
1067 | } // end WNT_EndMarkerNote :: Play |
1068 | //////////////////////////////////////////////////////////////////////////////// |
1069 | // W N T _ L i n e A t t r i b N o t e // |
1070 | //////////////////////////////////////////////////////////////////////////////// |
1071 | WNT_LineAttribNote :: WNT_LineAttribNote ( |
1072 | DWORD width, PLOGBRUSH plb, |
1073 | DWORD nStyles, PDWORD pdwStyle |
1074 | ) |
1075 | { |
1076 | myPointColor = plb -> lbColor; |
1077 | myWidth = ((width == 0) ? 1 : width); |
1078 | |
1079 | if ((width == 0 || width == 1) && (nStyles == 0)) { |
1080 | myPen = CreatePen (PS_SOLID, width, plb->lbColor); |
1081 | } else { |
1082 | DWORD pStyle = ( nStyles > 0 ? PS_USERSTYLE : PS_SOLID ); |
1083 | pStyle |= ( PS_ENDCAP_FLAT | PS_JOIN_MITER | PS_GEOMETRIC ); |
1084 | myPen = ExtCreatePen ( pStyle, width, plb, nStyles, pdwStyle ); |
1085 | if ( !myPen ) { |
1086 | char err[1024]; |
1087 | DWORD errCode = GetLastError(); |
1088 | printf ( " *** WNT_LineAttribNote : Can't create extended pen: %lu\n", errCode ); |
1089 | wsprintf ( err, "Can't create extended pen: %lu", errCode ); |
1090 | MessageBox ( NULL, err, "WNT_Allocator", MB_OK | MB_ICONEXCLAMATION ); |
1091 | myPen = CreatePen ( PS_SOLID, 1, RGB(170,170,70) ); |
1092 | } |
1093 | } |
1094 | Play ( FALSE ); |
1095 | } // end constructor |
1096 | |
1097 | WNT_LineAttribNote :: ~WNT_LineAttribNote ( void ) |
1098 | { |
1099 | #ifdef PRO19042 |
1100 | if ( myPen ) { |
1101 | #ifdef DEB |
1102 | printf(" *** Destroy:WNT_LineAttribNote %x/%x\n",myPen,ALLOCATOR->myLinePen); |
1103 | #endif |
1104 | DeletePen( myPen ); |
1105 | myPen = NULL; |
1106 | } |
1107 | #else |
1108 | if ( myPen && myPen != ALLOCATOR -> myLinePen ) |
1109 | DeletePen( myPen ); |
1110 | #endif |
1111 | } // enf WNT_LineAttribNote :: ~WNT_LineAttribNote |
1112 | |
1113 | void WNT_LineAttribNote :: Play ( BOOL fRealize ) |
1114 | { |
1115 | ALLOCATOR -> myLinePen = myPen; |
1116 | ALLOCATOR -> myLineWidth = myWidth; |
1117 | ALLOCATOR -> myPointColor = myPointColor; |
1118 | if ( fRealize ) |
1119 | SelectPen ( ALLOCATOR -> myHDC, myPen ); |
1120 | } // end WNT_LineAttribNote :: Play |
1121 | //////////////////////////////////////////////////////////////////////////////// |
1122 | // W N T _ P o l y A t t r i b N o t e // |
1123 | //////////////////////////////////////////////////////////////////////////////// |
1124 | WNT_PolyAttribNote :: WNT_PolyAttribNote ( |
1125 | PLOGBRUSH plb, BOOL fDrawEdge, int aFillMode |
1126 | ) |
1127 | { |
1128 | myfEdge = fDrawEdge; |
1129 | myNoFill = ( plb -> lbStyle == BS_NULL ); |
1130 | myBrush = CreateBrushIndirect ( plb ); |
1131 | Play ( FALSE ); |
1132 | } // end constructor |
1133 | |
1134 | WNT_PolyAttribNote :: ~WNT_PolyAttribNote ( void ) |
1135 | { |
1136 | #ifdef PRO19042 |
1137 | if ( myBrush ) { |
1138 | #ifdef DEB |
1139 | printf(" *** Destroy:WNT_PolyAttribNote %x/%x\n",myBrush,ALLOCATOR->myPolyBrush); |
1140 | #endif |
1141 | DeleteBrush( myBrush ); |
1142 | myBrush = NULL; |
1143 | } |
1144 | #else |
1145 | if ( myBrush && myBrush != ALLOCATOR -> myPolyBrush ) |
1146 | DeleteBrush( myBrush ); |
1147 | #endif |
1148 | } // enf WNT_PolyAttribNote :: ~WNT_PolyAttribNote |
1149 | |
1150 | void WNT_PolyAttribNote :: Play ( BOOL fRealize ) |
1151 | { |
1152 | if ( myfEdge ) ALLOCATOR -> myFlags |= W32F_POUTL; |
1153 | else ALLOCATOR -> myFlags &= ~W32F_POUTL; |
1154 | if ( myNoFill ) ALLOCATOR -> myFlags |= W32F_NOFIL; |
1155 | else ALLOCATOR -> myFlags &= ~W32F_NOFIL; |
1156 | ALLOCATOR -> myPolyBrush = myBrush; |
1157 | if ( fRealize ) { |
1158 | SelectPen ( ALLOCATOR -> myHDC, ALLOCATOR -> myLinePen ); |
1159 | SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myPolyBrush ); |
1160 | } |
1161 | } // end WNT_PolyAttribNote :: Play |
1162 | //////////////////////////////////////////////////////////////////////////////// |
1163 | // W N T _ T e x t A t t r i b N o t e // |
1164 | //////////////////////////////////////////////////////////////////////////////// |
1165 | WNT_TextAttribNote :: WNT_TextAttribNote ( |
1166 | HFONT hFont, COLORREF color, double slant, |
1167 | double hScale, double vScale, |
1168 | BOOL fUnderlined, BOOL fFree, BOOL fIndex |
1169 | ) |
1170 | { |
1171 | myFont = hFont; |
1172 | mySlant = (slant == 0.0 ? EPS : slant); |
1173 | myHScale = vScale; |
1174 | myVScale = hScale; |
1175 | myFlags = ( fUnderlined ? W32F_TFULINED : 0 ) | |
1176 | ( fIndex ? W32F_TINDEX : 0 ) | |
1177 | ( fFree ? W32F_TFREE : 0 ); |
1178 | myColor = color; |
1179 | myPen = CreatePen ( PS_SOLID, 0, color ); |
1180 | myBrush = CreateSolidBrush ( color ); |
1181 | Play ( FALSE ); |
1182 | } // end constructor |
1183 | |
1184 | WNT_TextAttribNote :: ~WNT_TextAttribNote () |
1185 | { |
1186 | #ifdef PRO19042 |
1187 | if ( myFont && (myFlags & W32F_TFREE) ) { |
1188 | #ifdef DEB |
1189 | printf(" *** Destroy:WNT_TextAttribNote_FONT %x/%x\n",myFont,ALLOCATOR->myTextFont); |
1190 | #endif |
1191 | DeleteFont ( myFont ); |
1192 | myFont = NULL; |
1193 | } |
1194 | if ( myPen ) { |
1195 | #ifdef DEB |
1196 | printf(" *** Destroy:WNT_TextAttribNote_PEN %x/%x\n",myPen,ALLOCATOR->myTextPen); |
1197 | #endif |
1198 | DeletePen ( myPen ); |
1199 | myPen = NULL; |
1200 | } |
1201 | if ( myBrush ) { |
1202 | #ifdef DEB |
1203 | printf(" *** Destroy:WNT_TextAttribNote_BRUSH %x/%x\n",myBrush,ALLOCATOR->myTextBrush); |
1204 | #endif |
1205 | DeleteBrush ( myBrush ); |
1206 | myBrush = NULL; |
1207 | } |
1208 | #else |
1209 | if ( myFlags & W32F_TFREE ) DeleteFont ( myFont ); |
1210 | if ( myPen && myPen != ALLOCATOR -> myTextPen ) DeletePen ( myPen ); |
1211 | if ( myBrush && myBrush != ALLOCATOR -> myTextBrush ) DeleteBrush ( myBrush ); |
1212 | #endif |
1213 | } // end destructor |
1214 | |
1215 | void WNT_TextAttribNote :: Play ( BOOL fRealize ) |
1216 | { |
1217 | if ( ( ALLOCATOR -> myFlags & W32F_DFONT ) && !( myFlags & W32F_TINDEX ) ) { |
1218 | DeleteFont( ALLOCATOR -> myTextFont ); |
1219 | ALLOCATOR -> myFlags &= ~W32F_DFONT; |
1220 | } // end if |
1221 | ALLOCATOR -> myTextFont = myFont; |
1222 | ALLOCATOR -> myTextSlant = mySlant; |
1223 | ALLOCATOR -> myTextHScale = myHScale; |
1224 | ALLOCATOR -> myTextVScale = myVScale; |
1225 | ALLOCATOR -> myTextColor = myColor; |
1226 | ALLOCATOR -> myTextPen = myPen; |
1227 | ALLOCATOR -> myTextBrush = myBrush; |
1228 | if (myFlags & W32F_TFULINED) ALLOCATOR -> myFlags |= W32F_TULIN; |
1229 | else ALLOCATOR -> myFlags &= ~W32F_TULIN; |
1230 | if ( fRealize && !( myFlags & W32F_TINDEX ) ) { |
1231 | SetTextColor ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextColor ); |
1232 | SelectPen ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextPen ); |
1233 | SelectBrush ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextBrush ); |
1234 | SelectFont ( ALLOCATOR -> myHDC, ALLOCATOR -> myTextFont ); |
1235 | } |
1236 | } // end WNT_TextAttribNote :: Play |
1237 | //////////////////////////////////////////////////////////////////////////////// |
1238 | // W N T _ M a r k e r A t t r i b N o t e // |
1239 | //////////////////////////////////////////////////////////////////////////////// |
1240 | WNT_MarkerAttribNote :: WNT_MarkerAttribNote ( |
1241 | COLORREF color, DWORD dwWidth, BOOL fFill |
1242 | ) |
1243 | { |
1244 | DWORD width = (dwWidth == 0) ? 1 : dwWidth; |
1245 | |
1246 | myFill = fFill; |
1247 | myMarkerPointColor = color; |
1248 | myPen = CreatePen ( PS_SOLID, width, color ); |
1249 | Play (); |
1250 | } // end constructor |
1251 | |
1252 | WNT_MarkerAttribNote :: ~WNT_MarkerAttribNote ( void ) |
1253 | { |
1254 | #ifdef PRO19042 |
1255 | if ( myPen ) { |
1256 | #ifdef DEB |
1257 | printf(" *** Destroy:WNT_MarkerAttribNote %x/%x\n",myPen,ALLOCATOR->myMarkerPen); |
1258 | #endif |
1259 | DeletePen( myPen ); |
1260 | myPen = NULL; |
1261 | } |
1262 | #else |
1263 | if ( myPen && myPen != ALLOCATOR -> myMarkerPen ) DeletePen( myPen ); |
1264 | #endif |
1265 | } // enf WNT_MarkerAttribNote :: ~WNT_MarkerAttribNote |
1266 | |
1267 | void WNT_MarkerAttribNote :: Play ( BOOL fRealize ) |
1268 | { |
1269 | if (myFill) ALLOCATOR -> myFlags |= W32F_MFILL; |
1270 | else ALLOCATOR -> myFlags &= ~W32F_MFILL; |
1271 | |
1272 | ALLOCATOR -> myMarkerPen = myPen; |
1273 | ALLOCATOR -> myMarkerPointColor = myMarkerPointColor; |
1274 | } // end WNT_MarkerAttribNote :: Play |