]> git.saurik.com Git - wxWidgets.git/blob - src/os2/dc.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Clear grid selection more consistently prior clear operations; improved Clear() tests...
[wxWidgets.git] / src / os2 / dc.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/os2/dc.cpp
3 // Purpose: wxDC class
4 // Author: David Webster
5 // Modified by:
6 // Created: 10/14/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/window.h"
17 #include "wx/dc.h"
18 #include "wx/utils.h"
19 #include "wx/dialog.h"
20 #include "wx/app.h"
21 #include "wx/bitmap.h"
22 #include "wx/dcmemory.h"
23 #include "wx/log.h"
24 #include "wx/icon.h"
25 #include "wx/msgdlg.h"
26 #include "wx/dcprint.h"
27 #include "wx/statusbr.h"
28 #include "wx/module.h"
29 #endif
30
31 #include <string.h>
32
33 #include "wx/os2/dc.h"
34 #include "wx/os2/dcclient.h"
35 #include "wx/os2/private.h"
36
37 IMPLEMENT_ABSTRACT_CLASS(wxPMDCImpl, wxDCImpl)
38
39 //
40 // wxWidgets uses the Microsoft convention that the origin is the UPPER left.
41 // Native OS/2 however in the GPI and PM define the origin as the LOWER left.
42 // In order to map OS/2 GPI/PM y coordinates to wxWidgets coordinates we must
43 // perform the following transformation:
44 //
45 // Parent object height: POBJHEIGHT
46 // Desried origin: WXORIGINY
47 // Object to place's height: OBJHEIGHT
48 //
49 // To get the OS2 position from the wxWidgets one:
50 //
51 // OS2Y = POBJHEIGHT - (WXORIGINY + OBJHEIGHT)
52 //
53 // For OS/2 wxDC's we will always determine m_vRclPaint as the size of the
54 // OS/2 Presentation Space associated with the device context. y is the
55 // desired application's y coordinate of the origin in wxWidgets space.
56 // objy is the height of the object we are going to draw.
57 //
58 #define OS2Y(y, objy) ((m_vRclPaint.yTop - m_vRclPaint.yBottom) - (y + objy))
59
60 // ---------------------------------------------------------------------------
61 // constants
62 // ---------------------------------------------------------------------------
63
64 static const int VIEWPORT_EXTENT = 1000;
65
66 static const int MM_POINTS = 9;
67 static const int MM_METRIC = 10;
68
69 // ---------------------------------------------------------------------------
70 // private functions
71 // ---------------------------------------------------------------------------
72
73 // convert degrees to radians
74 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
75
76 int SetTextColor(
77 HPS hPS
78 , int nForegroundColour
79 )
80 {
81 CHARBUNDLE vCbnd;
82
83 vCbnd.lColor = nForegroundColour;
84 ::GpiSetAttrs( hPS // presentation-space handle
85 ,PRIM_CHAR // Char primitive.
86 ,CBB_COLOR // sets color.
87 ,0 //
88 ,&vCbnd // buffer for attributes.
89 );
90 return 0;
91 }
92
93 int QueryTextBkColor(
94 HPS hPS
95 )
96 {
97 CHARBUNDLE vCbnd;
98
99 ::GpiQueryAttrs( hPS // presentation-space handle
100 ,PRIM_CHAR // Char primitive.
101 ,CBB_BACK_COLOR // Background color.
102 ,&vCbnd // buffer for attributes.
103 );
104 return vCbnd.lBackColor;
105 }
106
107
108 int SetTextBkColor(
109 HPS hPS
110 , int nBackgroundColour
111 )
112 {
113 CHARBUNDLE vCbnd;
114 int rc;
115
116 rc = QueryTextBkColor(hPS);
117
118 vCbnd.lBackColor = nBackgroundColour;
119 ::GpiSetAttrs(hPS, // presentation-space handle
120 PRIM_CHAR, // Char primitive.
121 CBB_BACK_COLOR, // sets color.
122 0,
123 &vCbnd // buffer for attributes.
124 );
125 return rc;
126 }
127
128 int SetBkMode(
129 HPS hPS
130 , int nBackgroundMode
131 )
132 {
133 if(nBackgroundMode == wxTRANSPARENT)
134 ::GpiSetBackMix( hPS
135 ,BM_LEAVEALONE
136 );
137 else
138 // the background of the primitive takes over whatever is underneath.
139 ::GpiSetBackMix( hPS
140 ,BM_OVERPAINT
141 );
142 return 0;
143 }
144
145 // ===========================================================================
146 // implementation
147 // ===========================================================================
148
149 #if wxUSE_DC_CACHEING
150
151 /*
152 * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
153 * improve it in due course, either using arrays, or simply storing pointers to one
154 * entry for the bitmap, and two for the DCs. -- JACS
155 */
156
157 // ---------------------------------------------------------------------------
158 // wxDCCacheEntry
159 // ---------------------------------------------------------------------------
160
161 wxList wxPMDCImpl::m_svBitmapCache;
162 wxList wxPMDCImpl::m_svDCCache;
163
164 wxDCCacheEntry::wxDCCacheEntry(
165 WXHBITMAP hBitmap
166 , int nWidth
167 , int nHeight
168 , int nDepth
169 )
170 {
171 m_hBitmap = hBitmap;
172 m_hPS = NULLHANDLE;
173 m_nWidth = nWidth;
174 m_nHeight = nHeight;
175 m_nDepth = nDepth;
176 } // end of wxDCCacheEntry::wxDCCacheEntry
177
178 wxDCCacheEntry::wxDCCacheEntry(
179 HPS hPS
180 , int nDepth
181 )
182 {
183 m_hBitmap = NULLHANDLE;
184 m_hPS = hPS;
185 m_nWidth = 0;
186 m_nHeight = 0;
187 m_nDepth = nDepth;
188 } // end of wxDCCacheEntry::wxDCCacheEntry
189
190 wxDCCacheEntry::~wxDCCacheEntry()
191 {
192 if (m_hBitmap)
193 ::GpiDeleteBitmap(m_hBitmap);
194 if (m_hPS)
195 ::GpiDestroyPS(m_hPS);
196 } // end of wxDCCacheEntry::~wxDCCacheEntry
197
198 wxDCCacheEntry* wxPMDCImpl::FindBitmapInCache(
199 HPS hPS
200 , int nWidth
201 , int nHeight
202 )
203 {
204 int nDepth = 24; // we'll fix this later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
205 wxNode* pNode = m_svBitmapCache.First();
206 BITMAPINFOHEADER2 vBmpHdr;
207
208 while(pNode)
209 {
210 wxDCCacheEntry* pEntry = (wxDCCacheEntry*)pNode->Data();
211
212 if (pEntry->m_nDepth == nDepth)
213 {
214 memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
215
216 if (pEntry->m_nWidth < nWidth || pEntry->m_nHeight < nHeight)
217 {
218 ::GpiDeleteBitmap((HBITMAP)pEntry->m_hBitmap);
219 vBmpHdr.cbFix = sizeof(BITMAPINFOHEADER2);
220 vBmpHdr.cx = nWidth;
221 vBmpHdr.cy = nHeight;
222 vBmpHdr.cPlanes = 1;
223 vBmpHdr.cBitCount = (USHORT)nDepth;
224
225 pEntry->m_hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
226 ,&vBmpHdr
227 ,0L, NULL, NULL
228 );
229 if (!pEntry->m_hBitmap)
230 {
231 wxLogLastError(wxT("CreateCompatibleBitmap"));
232 }
233 pEntry->m_nWidth = nWidth;
234 pEntry->m_nHeight = nHeight;
235 return pEntry;
236 }
237 return pEntry;
238 }
239 pNode = pNode->Next();
240 }
241 memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
242 vBmpHdr.cbFix = sizeof(BITMAPINFOHEADER2);
243 vBmpHdr.cx = nWidth;
244 vBmpHdr.cy = nHeight;
245 vBmpHdr.cPlanes = 1;
246 vBmpHdr.cBitCount = (USHORT)nDepth;
247
248 WXHBITMAP hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
249 ,&vBmpHdr
250 ,0L, NULL, NULL
251 );
252 if (!hBitmap)
253 {
254 wxLogLastError(wxT("CreateCompatibleBitmap"));
255 }
256 wxDCCacheEntry* pEntry = new wxDCCacheEntry( hBitmap
257 ,nWidth
258 ,nHeight
259 ,nDepth
260 );
261 AddToBitmapCache(pEntry);
262 return pEntry;
263 } // end of FindBitmapInCache
264
265 wxDCCacheEntry* wxPMDCImpl::FindDCInCache(
266 wxDCCacheEntry* pNotThis
267 , HPS hPS
268 )
269 {
270 int nDepth = 24; // we'll fix this up later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
271 wxNode* pNode = m_svDCCache.First();
272
273 while(pNode)
274 {
275 wxDCCacheEntry* pEntry = (wxDCCacheEntry*)pNode->Data();
276
277 //
278 // Don't return the same one as we already have
279 //
280 if (!pNotThis || (pNotThis != pEntry))
281 {
282 if (pEntry->m_nDepth == nDepth)
283 {
284 return pEntry;
285 }
286 }
287 pNode = pNode->Next();
288 }
289 wxDCCacheEntry* pEntry = new wxDCCacheEntry( hPS
290 ,nDepth
291 );
292 AddToDCCache(pEntry);
293 return pEntry;
294 } // end of wxPMDCImpl::FindDCInCache
295
296 void wxPMDCImpl::AddToBitmapCache(
297 wxDCCacheEntry* pEntry
298 )
299 {
300 m_svBitmapCache.Append(pEntry);
301 } // end of wxPMDCImpl::AddToBitmapCache
302
303 void wxPMDCImpl::AddToDCCache(
304 wxDCCacheEntry* pEntry
305 )
306 {
307 m_svDCCache.Append(pEntry);
308 } // end of wxPMDCImpl::AddToDCCache
309
310 void wxPMDCImpl::ClearCache()
311 {
312 m_svBitmapCache.DeleteContents(true);
313 m_svBitmapCache.Clear();
314 m_svBitmapCache.DeleteContents(false);
315 m_svDCCache.DeleteContents(true);
316 m_svDCCache.Clear();
317 m_svDCCache.DeleteContents(false);
318 } // end of wxPMDCImpl::ClearCache
319
320 // Clean up cache at app exit
321 class wxDCModule : public wxModule
322 {
323 public:
324 virtual bool OnInit() { return true; }
325 virtual void OnExit() { wxPMDCImpl::ClearCache(); }
326
327 private:
328 DECLARE_DYNAMIC_CLASS(wxDCModule)
329 }; // end of CLASS wxDCModule
330
331 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
332
333 #endif // ndef for wxUSE_DC_CACHEING
334
335 // ---------------------------------------------------------------------------
336 // wxDC
337 // ---------------------------------------------------------------------------
338
339 wxPMDCImpl::wxPMDCImpl( wxDC *owner, WXHDC hDC ) :
340 wxDCImpl( owner )
341 {
342 Init();
343 m_hDC = hDC;
344 } // end of wxPMDCImpl::wxPMDCImpl
345
346 wxPMDCImpl::~wxPMDCImpl(void)
347 {
348 if ( m_hDC != 0 )
349 {
350 SelectOldObjects(m_hDC);
351
352 // if we own the HDC, we delete it, otherwise we just release it
353
354 if (m_bOwnsDC)
355 {
356 if(m_hPS)
357 {
358 ::GpiAssociate(m_hPS, NULLHANDLE);
359 ::GpiDestroyPS(m_hPS);
360 }
361 m_hPS = NULLHANDLE;
362 ::DevCloseDC((HDC)m_hDC);
363 }
364 else
365 {
366 //
367 // Just Dissacociate, not destroy if we don't own the DC
368 //
369 if(m_hPS)
370 {
371 ::GpiAssociate(m_hPS, NULLHANDLE);
372 }
373 }
374 }
375 } // end of wxPMDCImpl::~wxDC
376
377 // This will select current objects out of the DC,
378 // which is what you have to do before deleting the
379 // DC.
380 void wxPMDCImpl::SelectOldObjects(
381 WXHDC hPS
382 )
383 {
384 if (hPS)
385 {
386 if (m_hOldBitmap)
387 {
388 ::GpiSetBitmap(hPS, (HBITMAP) m_hOldBitmap);
389 if (m_vSelectedBitmap.Ok())
390 {
391 m_vSelectedBitmap.SetSelectedInto(NULL);
392 }
393 }
394 m_hOldBitmap = 0;
395 //
396 // OS/2 has no other native GDI objects to set in a PS/DC like windows
397 //
398 m_hOldPen = 0;
399 m_hOldBrush = 0;
400 m_hOldFont = 0;
401 m_hOldPalette = 0;
402 }
403
404 m_brush = wxNullBrush;
405 m_pen = wxNullPen;
406 m_palette = wxNullPalette;
407 m_font = wxNullFont;
408 m_backgroundBrush = wxNullBrush;
409 m_vSelectedBitmap = wxNullBitmap;
410 } // end of wxPMDCImpl::SelectOldObjects
411
412 // ---------------------------------------------------------------------------
413 // clipping
414 // ---------------------------------------------------------------------------
415
416 #define DO_SET_CLIPPING_BOX() \
417 { \
418 RECTL rect; \
419 \
420 ::GpiQueryClipBox(m_hPS, &rect); \
421 \
422 m_clipX1 = (wxCoord) XDEV2LOG(rect.xLeft); \
423 m_clipY1 = (wxCoord) YDEV2LOG(rect.yTop); \
424 m_clipX2 = (wxCoord) XDEV2LOG(rect.xRight); \
425 m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
426 }
427
428 void wxPMDCImpl::DoSetClippingRegion(
429 wxCoord vX
430 , wxCoord vY
431 , wxCoord vWidth
432 , wxCoord vHeight
433 )
434 {
435 RECTL vRect;
436
437 vY = OS2Y(vY,vHeight);
438 m_clipping = true;
439 vRect.xLeft = vX;
440 vRect.yTop = vY + vHeight;
441 vRect.xRight = vX + vWidth;
442 vRect.yBottom = vY;
443 ::GpiIntersectClipRectangle(m_hPS, &vRect);
444 DO_SET_CLIPPING_BOX()
445 } // end of wxPMDCImpl::DoSetClippingRegion
446
447 void wxPMDCImpl::DoSetDeviceClippingRegion(
448 const wxRegion& rRegion
449 )
450 {
451 wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
452 HRGN hRgnOld;
453
454 m_clipping = true;
455 ::GpiSetClipRegion( m_hPS
456 ,(HRGN)rRegion.GetHRGN()
457 ,&hRgnOld
458 );
459 DO_SET_CLIPPING_BOX()
460 } // end of wxPMDCImpl::DoSetDeviceClippingRegion
461
462 void wxPMDCImpl::DestroyClippingRegion(void)
463 {
464 if (m_clipping && m_hPS)
465 {
466 HRGN hRgnOld;
467 RECTL vRect;
468
469 // TODO: this should restore the previous clipped region
470 // so that OnPaint processing works correctly, and
471 // the update doesn't get destroyed after the first
472 // DestroyClippingRegion
473 vRect.xLeft = XLOG2DEV(0);
474 vRect.yTop = YLOG2DEV(32000);
475 vRect.xRight = XLOG2DEV(32000);
476 vRect.yBottom = YLOG2DEV(0);
477
478 HRGN hRgn = ::GpiCreateRegion(m_hPS, 1, &vRect);
479
480 ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
481 }
482 ResetClipping();
483 } // end of wxPMDCImpl::DestroyClippingRegion
484
485 // ---------------------------------------------------------------------------
486 // query capabilities
487 // ---------------------------------------------------------------------------
488
489 bool wxPMDCImpl::CanDrawBitmap() const
490 {
491 return true;
492 }
493
494 bool wxPMDCImpl::CanGetTextExtent() const
495 {
496 LONG lTechnology = 0L;
497
498 ::DevQueryCaps(GetHDC(), CAPS_TECHNOLOGY, 1L, &lTechnology);
499 return (lTechnology == CAPS_TECH_RASTER_DISPLAY) || (lTechnology == CAPS_TECH_RASTER_PRINTER);
500 } // end of wxPMDCImpl::CanGetTextExtent
501
502 int wxPMDCImpl::GetDepth() const
503 {
504 LONG lCapsColorBitcount;
505 int nBitsPerPixel = 0;
506
507 if(::DevQueryCaps( GetHDC()
508 ,CAPS_COLOR_BITCOUNT
509 ,1L
510 ,&lCapsColorBitcount
511 ))
512 {
513 nBitsPerPixel = (int)lCapsColorBitcount;
514 }
515 return nBitsPerPixel;
516 } // end of wxPMDCImpl::GetDepth
517
518 // ---------------------------------------------------------------------------
519 // drawing
520 // ---------------------------------------------------------------------------
521
522 void wxPMDCImpl::Clear()
523 {
524 //
525 // If this is a canvas DC then just fill with the background color
526 // Otherwise purge the whole thing
527 //
528 if (m_pCanvas)
529 {
530 RECTL vRect;
531
532 ::GpiQueryClipBox(m_hPS, &vRect);
533 ::WinFillRect(m_hPS, &vRect, ::GpiQueryBackColor(m_hPS));
534 }
535 else
536 ::GpiErase(m_hPS);
537 } // end of wxPMDCImpl::Clear
538
539 bool wxPMDCImpl::DoFloodFill(
540 wxCoord vX
541 , wxCoord vY
542 , const wxColour& rCol
543 , wxFloodFillStyle nStyle
544 )
545 {
546 POINTL vPtlPos;
547 LONG lColor;
548 LONG lOptions;
549 LONG lHits;
550 bool bSuccess = false;
551
552 vPtlPos.x = vX; // Loads x-coordinate
553 vPtlPos.y = OS2Y(vY,0); // Loads y-coordinate
554 ::GpiMove(m_hPS, &vPtlPos); // Sets current position
555 lColor = rCol.GetPixel();
556 lOptions = FF_BOUNDARY;
557 if(wxFLOOD_SURFACE == nStyle)
558 lOptions = FF_SURFACE;
559
560 if ((lHits = ::GpiFloodFill(m_hPS, lOptions, lColor)) != GPI_ERROR)
561 bSuccess = true;
562
563 return bSuccess;
564 } // end of wxPMDCImpl::DoFloodFill
565
566 bool wxPMDCImpl::DoGetPixel(
567 wxCoord vX
568 , wxCoord vY
569 , wxColour* pCol
570 ) const
571 {
572 POINTL vPoint;
573 LONG lColor;
574
575 vPoint.x = vX;
576 vPoint.y = OS2Y(vY,0);
577 lColor = ::GpiQueryPel(m_hPS, &vPoint);
578
579 //
580 // return the color of the pixel
581 //
582 if(pCol)
583 pCol->Set( GetRValue(lColor)
584 ,GetGValue(lColor)
585 ,GetBValue(lColor)
586 );
587 return true;
588 } // end of wxPMDCImpl::DoGetPixel
589
590 void wxPMDCImpl::DoCrossHair(
591 wxCoord vX
592 , wxCoord vY
593 )
594 {
595 vY = OS2Y(vY,0);
596
597 wxCoord vX1 = vX - VIEWPORT_EXTENT;
598 wxCoord vY1 = vY - VIEWPORT_EXTENT;
599 wxCoord vX2 = vX + VIEWPORT_EXTENT;
600 wxCoord vY2 = vY + VIEWPORT_EXTENT;
601 POINTL vPoint[4];
602
603 vPoint[0].x = vX1;
604 vPoint[0].y = vY;
605
606 vPoint[1].x = vX2;
607 vPoint[1].y = vY;
608
609 ::GpiMove(m_hPS, &vPoint[0]);
610 ::GpiLine(m_hPS, &vPoint[1]);
611
612 vPoint[2].x = vX;
613 vPoint[2].y = vY1;
614
615 vPoint[3].x = vX;
616 vPoint[3].y = vY2;
617
618 ::GpiMove(m_hPS, &vPoint[2]);
619 ::GpiLine(m_hPS, &vPoint[3]);
620 CalcBoundingBox(vX1, vY1);
621 CalcBoundingBox(vX2, vY2);
622 } // end of wxPMDCImpl::DoCrossHair
623
624 void wxPMDCImpl::DoDrawLine(
625 wxCoord vX1
626 , wxCoord vY1
627 , wxCoord vX2
628 , wxCoord vY2
629 )
630 {
631 POINTL vPoint[2];
632 COLORREF vColor = 0x00ffffff;
633
634 //
635 // Might be a memory DC with no Paint rect.
636 //
637 if (!(m_vRclPaint.yTop == 0 &&
638 m_vRclPaint.yBottom == 0 &&
639 m_vRclPaint.xRight == 0 &&
640 m_vRclPaint.xLeft == 0))
641 {
642 vY1 = OS2Y(vY1,0);
643 vY2 = OS2Y(vY2,0);
644 }
645 else
646 {
647 if (m_vSelectedBitmap.Ok())
648 {
649 m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
650 m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
651 vY1 = OS2Y(vY1,0);
652 vY2 = OS2Y(vY2,0);
653 }
654 }
655 vPoint[0].x = vX1;
656 vPoint[0].y = vY1;
657 vPoint[1].x = vX2;
658 vPoint[1].y = vY2;
659 if (m_pen.Ok())
660 {
661 vColor = m_pen.GetColour().GetPixel();
662 }
663 ::GpiSetColor(m_hPS, vColor);
664 ::GpiMove(m_hPS, &vPoint[0]);
665 ::GpiLine(m_hPS, &vPoint[1]);
666 CalcBoundingBox(vX1, vY1);
667 CalcBoundingBox(vX2, vY2);
668 } // end of wxPMDCImpl::DoDrawLine
669
670 //////////////////////////////////////////////////////////////////////////////
671 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
672 // and ending at (x2, y2). The current pen is used for the outline and the
673 // current brush for filling the shape. The arc is drawn in an anticlockwise
674 // direction from the start point to the end point.
675 //////////////////////////////////////////////////////////////////////////////
676 void wxPMDCImpl::DoDrawArc(
677 wxCoord vX1
678 , wxCoord vY1
679 , wxCoord vX2
680 , wxCoord vY2
681 , wxCoord vXc
682 , wxCoord vYc
683 )
684 {
685 POINTL vPtlPos;
686 POINTL vPtlArc[2]; // Structure for current position
687 double dRadius;
688 double dAngl1;
689 double dAngl2;
690 double dAnglmid;
691 wxCoord vXm;
692 wxCoord vYm;
693 ARCPARAMS vArcp; // Structure for arc parameters
694
695 if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
696 return; // Draw point ??
697 dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
698 ,(double)(vX1 - vXc)
699 ) +
700 hypot( (double)(vY2 - vYc)
701 ,(double)(vX2 - vXc)
702 )
703 );
704
705 dAngl1 = atan2( (double)(vY1 - vYc)
706 ,(double)(vX1 - vXc)
707 );
708 dAngl2 = atan2( (double)(vY2 - vYc)
709 ,(double)(vX2 - vXc)
710 );
711 if(dAngl2 < dAngl1)
712 dAngl2 += M_PI * 2;
713
714 //
715 // GpiPointArc can't draw full arc
716 //
717 if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
718 {
719 //
720 // Medium point
721 //
722 dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
723 vXm = (wxCoord)(vXc + dRadius * cos(dAnglmid));
724 vYm = (wxCoord)(vYc + dRadius * sin(dAnglmid));
725 DoDrawArc( vX1, vY1
726 ,vXm, vYm
727 ,vXc, vYc
728 );
729 DoDrawArc( vXm, vYm
730 ,vX2, vY2
731 ,vXc, vYc
732 );
733 return;
734 }
735
736 //
737 // Medium point
738 //
739 dAnglmid = (dAngl1 + dAngl2)/2.;
740 vXm = (wxCoord)(vXc + dRadius * cos(dAnglmid));
741 vYm = (wxCoord)(vYc + dRadius * sin(dAnglmid));
742
743 //
744 // Ellipse main axis (r,q), (p,s) with center at (0,0) */
745 //
746 vArcp.lR = 0;
747 vArcp.lQ = 1;
748 vArcp.lP = 1;
749 vArcp.lS = 0;
750 ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
751
752 vPtlPos.x = vX1; // Loads x-coordinate
753 vPtlPos.y = vY1; // Loads y-coordinate
754 ::GpiMove(m_hPS, &vPtlPos); // Sets current position
755 vPtlArc[0].x = vXm;
756 vPtlArc[0].y = vYm;
757 vPtlArc[1].x = vX2;
758 vPtlArc[1].y = vY2;
759 ::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
760 CalcBoundingBox( (wxCoord)(vXc - dRadius)
761 ,(wxCoord)(vYc - dRadius)
762 );
763 CalcBoundingBox( (wxCoord)(vXc + dRadius)
764 ,(wxCoord)(vYc + dRadius)
765 );
766 } // end of wxPMDCImpl::DoDrawArc
767
768 void wxPMDCImpl::DoDrawCheckMark(
769 wxCoord vX1
770 , wxCoord vY1
771 , wxCoord vWidth
772 , wxCoord vHeight
773 )
774 {
775 POINTL vPoint[2];
776
777 vY1 = OS2Y(vY1,vHeight);
778
779 vPoint[0].x = vX1;
780 vPoint[0].y = vY1;
781 vPoint[1].x = vX1 + vWidth;
782 vPoint[1].y = vY1 + vHeight;
783
784 ::GpiMove(m_hPS, &vPoint[0]);
785 ::GpiBox( m_hPS // handle to a presentation space
786 ,DRO_OUTLINE // draw the box outline ? or ?
787 ,&vPoint[1] // address of the corner
788 ,0L // horizontal corner radius
789 ,0L // vertical corner radius
790 );
791 if(vWidth > 4 && vHeight > 4)
792 {
793 int nTmp;
794
795 vPoint[0].x += 2; vPoint[0].y += 2;
796 vPoint[1].x -= 2; vPoint[1].y -= 2;
797 ::GpiMove(m_hPS, &vPoint[0]);
798 ::GpiLine(m_hPS, &vPoint[1]);
799 nTmp = vPoint[0].x;
800 vPoint[0].x = vPoint[1].x;
801 vPoint[1].x = nTmp;
802 ::GpiMove(m_hPS, &vPoint[0]);
803 ::GpiLine(m_hPS, &vPoint[1]);
804 }
805 CalcBoundingBox( vX1
806 ,vY1
807 );
808
809 wxCoord vX2 = vX1 + vWidth;
810 wxCoord vY2 = vY1 + vHeight;
811
812 CalcBoundingBox( vX2
813 ,vY2
814 );
815 } // end of wxPMDCImpl::DoDrawCheckMark
816
817 void wxPMDCImpl::DoDrawPoint(
818 wxCoord vX
819 , wxCoord vY
820 )
821 {
822 POINTL vPoint;
823 COLORREF vColor = 0x00ffffff;
824
825 if (m_pen.Ok())
826 {
827 vColor = m_pen.GetColour().GetPixel();
828 }
829 ::GpiSetColor(m_hPS, vColor);
830 vPoint.x = vX;
831 vPoint.y = OS2Y(vY,0);
832 ::GpiSetPel(m_hPS, &vPoint);
833 CalcBoundingBox( vX
834 ,vY
835 );
836 } // end of wxPMDCImpl::DoDrawPoint
837
838 void wxPMDCImpl::DoDrawPolygon( int n,
839 wxPoint vPoints[],
840 wxCoord vXoffset,
841 wxCoord vYoffset,
842 wxPolygonFillMode nFillStyle )
843 {
844 ULONG ulCount = 1; // Number of polygons.
845 POLYGON vPlgn; // polygon.
846 ULONG flOptions = 0L; // Drawing options.
847
848 //////////////////////////////////////////////////////////////////////////////
849 // This contains fields of option bits... to draw boundary lines as well as
850 // the area interior.
851 //
852 // Drawing boundary lines:
853 // POLYGON_NOBOUNDARY Does not draw boundary lines.
854 // POLYGON_BOUNDARY Draws boundary lines (the default).
855 //
856 // Construction of the area interior:
857 // POLYGON_ALTERNATE Constructs interior in alternate mode
858 // (the default).
859 // POLYGON_WINDING Constructs interior in winding mode.
860 //////////////////////////////////////////////////////////////////////////////
861
862 ULONG flModel = POLYGON_INCL; // Drawing model.
863
864 //////////////////////////////////////////////////////////////////////////////
865 // Drawing model.
866 // POLYGON_INCL Fill is inclusive of bottom right (the default).
867 // POLYGON_EXCL Fill is exclusive of bottom right.
868 // This is provided to aid migration from other graphics models.
869 //////////////////////////////////////////////////////////////////////////////
870
871 LONG lHits = 0L; // Correlation/error indicator.
872 int i;
873 int nIsTRANSPARENT = 0;
874 LONG lBorderColor = 0L;
875 LONG lColor = 0L;
876
877 lBorderColor = m_pen.GetColour().GetPixel();
878 lColor = m_brush.GetColour().GetPixel();
879 if(m_brush.GetStyle() == wxTRANSPARENT)
880 nIsTRANSPARENT = 1;
881
882 vPlgn.ulPoints = n;
883 vPlgn.aPointl = (POINTL*) calloc( n + 1
884 ,sizeof(POINTL)
885 ); // well, new will call malloc
886
887 for(i = 0; i < n; i++)
888 {
889 vPlgn.aPointl[i].x = vPoints[i].x+vXoffset;
890 vPlgn.aPointl[i].y = OS2Y(vPoints[i].y+vYoffset,0);
891 }
892 flOptions = POLYGON_BOUNDARY;
893 if(nFillStyle == wxWINDING_RULE)
894 flOptions |= POLYGON_WINDING;
895 else
896 flOptions |= POLYGON_ALTERNATE;
897
898 ::GpiSetColor(m_hPS, lBorderColor);
899 ::GpiMove(m_hPS, &vPlgn.aPointl[0]);
900 lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
901 free(vPlgn.aPointl);
902 } // end of wxPMDCImpl::DoDrawPolygon
903
904 void wxPMDCImpl::DoDrawLines(
905 int n
906 , wxPoint vPoints[]
907 , wxCoord vXoffset
908 , wxCoord vYoffset
909 )
910 {
911 POINTL vPoint;
912
913 if (vXoffset != 0L || vXoffset != 0L)
914 {
915 int i;
916
917 vPoint.x = vPoints[0].x + vXoffset;
918 vPoint.y = OS2Y(vPoints[0].y + vYoffset,0);
919 ::GpiMove(m_hPS, &vPoint);
920
921 LONG lBorderColor = m_pen.GetColour().GetPixel();
922
923 ::GpiSetColor(m_hPS, lBorderColor);
924 for(i = 1; i < n; i++)
925 {
926 vPoint.x = vPoints[i].x + vXoffset;
927 vPoint.y = OS2Y(vPoints[i].y + vYoffset,0);
928 ::GpiLine(m_hPS, &vPoint);
929 }
930 }
931 else
932 {
933 int i;
934
935 CalcBoundingBox( vPoints[0].x
936 ,vPoints[0].y
937 );
938 vPoint.x = vPoints[0].x;
939 vPoint.y = OS2Y(vPoints[0].y,0);
940 ::GpiMove(m_hPS, &vPoint);
941
942 for (i = 0; i < n; i++)
943 {
944 CalcBoundingBox( vPoints[i].x
945 ,vPoints[i].y
946 );
947 vPoint.x = vPoints[i].x;
948 vPoint.y = OS2Y(vPoints[i].y,0);
949 ::GpiLine(m_hPS, &vPoint);
950 }
951 }
952 } // end of wxPMDCImpl::DoDrawLines
953
954 void wxPMDCImpl::DoDrawRectangle(
955 wxCoord vX
956 , wxCoord vY
957 , wxCoord vWidth
958 , wxCoord vHeight
959 )
960 {
961 POINTL vPoint[2];
962 LONG lControl;
963 LONG lColor;
964 LONG lBorderColor;
965 int nIsTRANSPARENT = 0;
966
967 //
968 // Might be a memory DC with no Paint rect.
969 //
970 if (!(m_vRclPaint.yTop == 0 &&
971 m_vRclPaint.yBottom == 0 &&
972 m_vRclPaint.xRight == 0 &&
973 m_vRclPaint.xLeft == 0))
974 vY = OS2Y(vY,vHeight);
975 else
976 {
977 if (m_vSelectedBitmap.Ok())
978 {
979 m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
980 m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
981 vY = OS2Y(vY,vHeight);
982 }
983 }
984
985 wxCoord vX2 = vX + vWidth;
986 wxCoord vY2 = vY + vHeight;
987
988 vPoint[0].x = vX;
989 vPoint[0].y = vY;
990 vPoint[1].x = vX + vWidth - 1;
991 vPoint[1].y = vY + vHeight - 1;
992 ::GpiMove(m_hPS, &vPoint[0]);
993 lColor = m_brush.GetColour().GetPixel();
994 lBorderColor = m_pen.GetColour().GetPixel();
995 if (m_brush.GetStyle() == wxTRANSPARENT)
996 nIsTRANSPARENT = 1;
997 if(lColor == lBorderColor || nIsTRANSPARENT)
998 {
999 lControl = DRO_OUTLINEFILL; //DRO_FILL;
1000 if(m_brush.GetStyle() == wxTRANSPARENT)
1001 lControl = DRO_OUTLINE;
1002
1003 ::GpiSetColor(m_hPS, lBorderColor);
1004 ::GpiBox( m_hPS // handle to a presentation space
1005 ,lControl // draw the box outline ? or ?
1006 ,&vPoint[1] // address of the corner
1007 ,0L // horizontal corner radius
1008 ,0L // vertical corner radius
1009 );
1010 }
1011 else
1012 {
1013 lControl = DRO_OUTLINE;
1014 ::GpiSetColor( m_hPS
1015 ,lBorderColor
1016 );
1017 ::GpiBox( m_hPS
1018 ,lControl
1019 ,&vPoint[1]
1020 ,0L
1021 ,0L
1022 );
1023 lControl = DRO_FILL;
1024 ::GpiSetColor( m_hPS
1025 ,lColor
1026 );
1027 vPoint[0].x = vX + 1;
1028 vPoint[0].y = vY + 1;
1029 vPoint[1].x = vX + vWidth - 2;
1030 vPoint[1].y = vY + vHeight - 2;
1031 ::GpiMove(m_hPS, &vPoint[0]);
1032 ::GpiBox( m_hPS
1033 ,lControl
1034 ,&vPoint[1]
1035 ,0L
1036 ,0L
1037 );
1038 }
1039 CalcBoundingBox(vX, vY);
1040 CalcBoundingBox(vX2, vY2);
1041 } // end of wxPMDCImpl::DoDrawRectangle
1042
1043 void wxPMDCImpl::DoDrawRoundedRectangle(
1044 wxCoord vX
1045 , wxCoord vY
1046 , wxCoord vWidth
1047 , wxCoord vHeight
1048 , double dRadius
1049 )
1050 {
1051 POINTL vPoint[2];
1052 LONG lControl;
1053 LONG lColor;
1054 LONG lBorderColor;
1055 int nIsTRANSPARENT = 0;
1056
1057 //
1058 // Might be a memory DC with no Paint rect.
1059 //
1060 if (!(m_vRclPaint.yTop == 0 &&
1061 m_vRclPaint.yBottom == 0 &&
1062 m_vRclPaint.xRight == 0 &&
1063 m_vRclPaint.xLeft == 0))
1064 vY = OS2Y(vY,vHeight);
1065 else
1066 {
1067 if (m_vSelectedBitmap.Ok())
1068 {
1069 m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
1070 m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
1071 vY = OS2Y(vY,vHeight);
1072 }
1073 }
1074
1075 wxCoord vX2 = (vX + vWidth);
1076 wxCoord vY2 = (vY + vHeight);
1077
1078 vPoint[0].x = vX;
1079 vPoint[0].y = vY;
1080 vPoint[1].x = vX + vWidth - 1;
1081 vPoint[1].y = vY + vHeight - 1;
1082 ::GpiMove(m_hPS, &vPoint[0]);
1083
1084 lColor = m_brush.GetColour().GetPixel();
1085 lBorderColor = m_pen.GetColour().GetPixel();
1086 lControl = DRO_OUTLINEFILL; //DRO_FILL;
1087 if (m_brush.GetStyle() == wxTRANSPARENT)
1088 nIsTRANSPARENT = 1;
1089 if(lColor == lBorderColor || nIsTRANSPARENT)
1090 {
1091 lControl = DRO_OUTLINEFILL; //DRO_FILL;
1092 if(m_brush.GetStyle() == wxTRANSPARENT)
1093 lControl = DRO_OUTLINE;
1094
1095 ::GpiSetColor(m_hPS, lColor);
1096 ::GpiBox( m_hPS // handle to a presentation space
1097 ,lControl // draw the box outline ? or ?
1098 ,&vPoint[1] // address of the corner
1099 ,(LONG)dRadius // horizontal corner radius
1100 ,(LONG)dRadius // vertical corner radius
1101 );
1102 }
1103 else
1104 {
1105 lControl = DRO_OUTLINE;
1106 ::GpiSetColor( m_hPS
1107 ,lBorderColor
1108 );
1109 ::GpiBox( m_hPS
1110 ,lControl
1111 ,&vPoint[1]
1112 ,(LONG)dRadius
1113 ,(LONG)dRadius
1114 );
1115 lControl = DRO_FILL;
1116 ::GpiSetColor( m_hPS
1117 ,lColor
1118 );
1119 vPoint[0].x = vX + 1;
1120 vPoint[0].y = vY + 1;
1121 vPoint[1].x = vX + vWidth - 2;
1122 vPoint[1].y = vY + vHeight - 2;
1123 ::GpiMove(m_hPS, &vPoint[0]);
1124 ::GpiBox( m_hPS
1125 ,lControl
1126 ,&vPoint[1]
1127 ,(LONG)dRadius
1128 ,(LONG)dRadius
1129 );
1130 }
1131
1132 CalcBoundingBox(vX, vY);
1133 CalcBoundingBox(vX2, vY2);
1134 } // end of wxPMDCImpl::DoDrawRoundedRectangle
1135
1136 // Draw Ellipse within box (x,y) - (x+width, y+height)
1137 void wxPMDCImpl::DoDrawEllipse(
1138 wxCoord vX
1139 , wxCoord vY
1140 , wxCoord vWidth
1141 , wxCoord vHeight
1142 )
1143 {
1144 POINTL vPtlPos; // Structure for current position
1145 FIXED vFxMult; // Multiplier for ellipse
1146 ARCPARAMS vArcp; // Structure for arc parameters
1147
1148 vY = OS2Y(vY,vHeight);
1149
1150 vArcp.lR = 0;
1151 vArcp.lQ = vHeight/2;
1152 vArcp.lP = vWidth/2;
1153 vArcp.lS = 0;
1154 ::GpiSetArcParams( m_hPS
1155 ,&vArcp
1156 ); // Sets parameters to default
1157 vPtlPos.x = vX + vWidth/2; // Loads x-coordinate
1158 vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
1159 ::GpiMove( m_hPS
1160 ,&vPtlPos
1161 ); // Sets current position
1162 vFxMult = MAKEFIXED(1, 0); /* Sets multiplier */
1163
1164 //
1165 // DRO_FILL, DRO_OTLINEFILL - where to get
1166 //
1167 ::GpiFullArc( m_hPS
1168 ,DRO_OUTLINE
1169 ,vFxMult
1170 ); // Draws full arc with center at current position
1171
1172 wxCoord vX2 = (vX + vWidth);
1173 wxCoord vY2 = (vY + vHeight);
1174
1175 CalcBoundingBox(vX, vY);
1176 CalcBoundingBox(vX2, vY2);
1177 } // end of wxPMDCImpl::DoDrawEllipse
1178
1179 void wxPMDCImpl::DoDrawEllipticArc(
1180 wxCoord vX
1181 , wxCoord vY
1182 , wxCoord vWidth
1183 , wxCoord vHeight
1184 , double dSa
1185 , double dEa
1186 )
1187 {
1188 POINTL vPtlPos; // Structure for current position
1189 FIXED vFxMult; // Multiplier for ellipse
1190 ARCPARAMS vArcp; // Structure for arc parameters
1191 FIXED vFSa;
1192 FIXED vFSweepa; // Start angle, sweep angle
1193 double dIntPart;
1194 double dFractPart;
1195
1196 vY = OS2Y(vY,vHeight);
1197
1198 dFractPart = modf(dSa,&dIntPart);
1199 vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
1200 dFractPart = modf(dEa - dSa, &dIntPart);
1201 vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
1202
1203 //
1204 // Ellipse main axis (r,q), (p,s) with center at (0,0)
1205 //
1206 vArcp.lR = 0;
1207 vArcp.lQ = vHeight/2;
1208 vArcp.lP = vWidth/2;
1209 vArcp.lS = 0;
1210 ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
1211 vPtlPos.x = (wxCoord)(vX + vWidth/2 * (1. + cos(DegToRad(dSa)))); // Loads x-coordinate
1212 vPtlPos.y = (wxCoord)(vY + vHeight/2 * (1. + sin(DegToRad(dSa)))); // Loads y-coordinate
1213 ::GpiMove(m_hPS, &vPtlPos); // Sets current position
1214
1215 //
1216 // May be not to the center ?
1217 //
1218 vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
1219 vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
1220 vFxMult = MAKEFIXED(1, 0); // Sets multiplier
1221
1222 //
1223 // DRO_FILL, DRO_OTLINEFILL - where to get
1224 //
1225 ::GpiPartialArc( m_hPS
1226 ,&vPtlPos
1227 ,vFxMult
1228 ,vFSa
1229 ,vFSweepa
1230 );
1231 wxCoord vX2 = (vX + vWidth);
1232 wxCoord vY2 = (vY + vHeight);
1233
1234 CalcBoundingBox(vX, vY);
1235 CalcBoundingBox(vX2, vY2);
1236 } // end of wxPMDCImpl::DoDrawEllipticArc
1237
1238 void wxPMDCImpl::DoDrawIcon(
1239 const wxIcon& rIcon
1240 , wxCoord vX
1241 , wxCoord vY
1242 )
1243 {
1244 //
1245 // Need to copy back into a bitmap. ::WinDrawPointer uses device coords
1246 // and I don't feel like figuring those out for scrollable windows so
1247 // just convert to a bitmap then let the DoDrawBitmap routine display it
1248 //
1249 if (rIcon.IsXpm())
1250 {
1251 DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, true);
1252 }
1253 else
1254 {
1255 wxBitmap vBitmap(rIcon);
1256
1257 DoDrawBitmap(vBitmap, vX, vY, false);
1258 }
1259 CalcBoundingBox(vX, vY);
1260 CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
1261 } // end of wxPMDCImpl::DoDrawIcon
1262
1263 void wxPMDCImpl::DoDrawBitmap(
1264 const wxBitmap& rBmp
1265 , wxCoord vX
1266 , wxCoord vY
1267 , bool bUseMask
1268 )
1269 {
1270 #if wxUSE_PRINTING_ARCHITECTURE
1271 if (!IsKindOf(CLASSINFO(wxPrinterDC)))
1272 #endif
1273 {
1274 HBITMAP hBitmap = (HBITMAP)rBmp.GetHBITMAP();
1275 HBITMAP hBitmapOld = NULLHANDLE;
1276 POINTL vPoint[4];
1277
1278 vY = OS2Y(vY,rBmp.GetHeight());
1279
1280 vPoint[0].x = vX;
1281 vPoint[0].y = vY + rBmp.GetHeight();
1282 vPoint[1].x = vX + rBmp.GetWidth();
1283 vPoint[1].y = vY;
1284 vPoint[2].x = 0;
1285 vPoint[2].y = 0;
1286 vPoint[3].x = rBmp.GetWidth();
1287 vPoint[3].y = rBmp.GetHeight();
1288 if (bUseMask)
1289 {
1290 wxMask* pMask = rBmp.GetMask();
1291
1292 if (pMask)
1293 {
1294 //
1295 // Need to imitate ::MaskBlt in windows.
1296 // 1) Extract the bits from from the bitmap.
1297 // 2) Extract the bits from the mask
1298 // 3) Using the mask bits do the following:
1299 // A) If the mask byte is 00 leave the bitmap byte alone
1300 // B) If the mask byte is FF copy the screen color into
1301 // bitmap byte
1302 // 4) Create a new bitmap and set its bits to the above result
1303 // 5) Blit this to the screen PS
1304 //
1305 HBITMAP hMask = (HBITMAP)pMask->GetMaskBitmap();
1306 HBITMAP hOldMask = NULLHANDLE;
1307 HBITMAP hOldBitmap = NULLHANDLE;
1308 HBITMAP hNewBitmap = NULLHANDLE;
1309 unsigned char* pucBits; // buffer that will contain the bitmap data
1310 unsigned char* pucBitsMask; // buffer that will contain the mask data
1311 unsigned char* pucData; // pointer to use to traverse bitmap data
1312 unsigned char* pucDataMask; // pointer to use to traverse mask data
1313 LONG lHits;
1314 ERRORID vError;
1315 wxString sError;
1316
1317 //
1318 // The usual Memory context creation stuff
1319 //
1320 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1321 SIZEL vSize = {0, 0};
1322 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1323 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
1324
1325 //
1326 // The usual bitmap header stuff
1327 //
1328 BITMAPINFOHEADER2 vHeader;
1329 BITMAPINFO2 vInfo;
1330
1331 memset(&vHeader, '\0', 16);
1332 vHeader.cbFix = 16;
1333
1334 memset(&vInfo, '\0', 16);
1335 vInfo.cbFix = 16;
1336 vInfo.cx = (ULONG)rBmp.GetWidth();
1337 vInfo.cy = (ULONG)rBmp.GetHeight();
1338 vInfo.cPlanes = 1;
1339 vInfo.cBitCount = 24; // Set to desired count going in
1340
1341 //
1342 // Create the buffers for data....all wxBitmaps are 24 bit internally
1343 //
1344 int nBytesPerLine = rBmp.GetWidth() * 3;
1345 int nSizeDWORD = sizeof(DWORD);
1346 int nLineBoundary = nBytesPerLine % nSizeDWORD;
1347 int nPadding = 0;
1348 int i;
1349 int j;
1350 LONG lScans = 0L;
1351 LONG lColor = 0L;
1352
1353 //
1354 // Need to get a background color for mask blitting
1355 //
1356 if (IsKindOf(CLASSINFO(wxWindowDCImpl)))
1357 {
1358 wxWindowDCImpl* pWindowDC = wxDynamicCast(this, wxWindowDCImpl);
1359
1360 lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
1361 }
1362 else if (GetBrush().Ok())
1363 lColor = GetBrush().GetColour().GetPixel();
1364 else
1365 lColor = m_textBackgroundColour.GetPixel();
1366
1367 //
1368 // Bitmap must be in a double-word aligned address so we may
1369 // have some padding to worry about
1370 //
1371 if (nLineBoundary > 0)
1372 {
1373 nPadding = nSizeDWORD - nLineBoundary;
1374 nBytesPerLine += nPadding;
1375 }
1376 pucBits = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
1377 pucBitsMask = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
1378 memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
1379 memset(pucBitsMask, '\0', (nBytesPerLine * rBmp.GetHeight()));
1380
1381 //
1382 // Extract the bitmap and mask data
1383 //
1384 if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
1385 {
1386 vError = ::WinGetLastError(vHabmain);
1387 sError = wxPMErrorToStr(vError);
1388 }
1389 ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
1390 vInfo.cBitCount = 24;
1391 if ((lScans = ::GpiQueryBitmapBits( hPS
1392 ,0L
1393 ,(LONG)rBmp.GetHeight()
1394 ,(PBYTE)pucBits
1395 ,&vInfo
1396 )) == GPI_ALTERROR)
1397 {
1398 vError = ::WinGetLastError(vHabmain);
1399 sError = wxPMErrorToStr(vError);
1400 }
1401 if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
1402 {
1403 vError = ::WinGetLastError(vHabmain);
1404 sError = wxPMErrorToStr(vError);
1405 }
1406 ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
1407 vInfo.cBitCount = 24;
1408 if ((lScans = ::GpiQueryBitmapBits( hPS
1409 ,0L
1410 ,(LONG)rBmp.GetHeight()
1411 ,(PBYTE)pucBitsMask
1412 ,&vInfo
1413 )) == GPI_ALTERROR)
1414 {
1415 vError = ::WinGetLastError(vHabmain);
1416 sError = wxPMErrorToStr(vError);
1417 }
1418 if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
1419 {
1420 vError = ::WinGetLastError(vHabmain);
1421 sError = wxPMErrorToStr(vError);
1422 }
1423
1424 //
1425 // Now set the bytes(bits) according to the mask values
1426 // 3 bytes per pel...must handle one at a time
1427 //
1428 pucData = pucBits;
1429 pucDataMask = pucBitsMask;
1430
1431 //
1432 // 16 bit kludge really only kinda works. The mask gets applied
1433 // where needed but the original bitmap bits are dorked sometimes
1434 //
1435 bool bpp16 = (wxDisplayDepth() == 16);
1436
1437 for (i = 0; i < rBmp.GetHeight(); i++)
1438 {
1439 for (j = 0; j < rBmp.GetWidth(); j++)
1440 {
1441 // Byte 1
1442 if (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
1443 pucData++;
1444 else if (*pucDataMask == 0xFF) // leave bitmap byte alone
1445 pucData++;
1446 else
1447 {
1448 *pucData = ((unsigned char)(lColor >> 16));
1449 pucData++;
1450 }
1451 // Byte 2
1452 if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
1453 pucData++;
1454 else if (*(pucDataMask + 1) == 0xFF) // leave bitmap byte alone
1455 pucData++;
1456 else
1457 {
1458 *pucData = ((unsigned char)(lColor >> 8));
1459 pucData++;
1460 }
1461
1462 // Byte 3
1463 if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
1464 pucData++;
1465 else if (*(pucDataMask + 2) == 0xFF) // leave bitmap byte alone
1466 pucData++;
1467 else
1468 {
1469 *pucData = ((unsigned char)lColor);
1470 pucData++;
1471 }
1472 pucDataMask += 3;
1473 }
1474 for (j = 0; j < nPadding; j++)
1475 {
1476 pucData++;
1477 pucDataMask++;
1478 }
1479 }
1480 //
1481 // Create a new bitmap
1482 //
1483 vHeader.cx = (ULONG)rBmp.GetWidth();
1484 vHeader.cy = (ULONG)rBmp.GetHeight();
1485 vHeader.cPlanes = 1L;
1486 vHeader.cBitCount = 24;
1487 if ((hNewBitmap = ::GpiCreateBitmap( hPS
1488 ,&vHeader
1489 ,CBM_INIT
1490 ,(PBYTE)pucBits
1491 ,&vInfo
1492 )) == GPI_ERROR)
1493 {
1494 vError = ::WinGetLastError(vHabmain);
1495 sError = wxPMErrorToStr(vError);
1496 }
1497
1498 //
1499 // Now blit it to the screen PS
1500 //
1501 if ((lHits = ::GpiWCBitBlt( (HPS)GetHPS()
1502 ,hNewBitmap
1503 ,4
1504 ,vPoint
1505 ,ROP_SRCCOPY
1506 ,BBO_IGNORE
1507 )) == GPI_ERROR)
1508 {
1509 vError = ::WinGetLastError(vHabmain);
1510 sError = wxPMErrorToStr(vError);
1511 }
1512
1513 //
1514 // Clean up
1515 //
1516 free(pucBits);
1517 free(pucBitsMask);
1518 ::GpiSetBitmap(hPS, NULLHANDLE);
1519 ::GpiDeleteBitmap(hNewBitmap);
1520 ::GpiDestroyPS(hPS);
1521 ::DevCloseDC(hDC);
1522 }
1523 }
1524 else
1525 {
1526 ULONG lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
1527 ULONG lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
1528
1529 if (m_textForegroundColour.Ok())
1530 {
1531 ::GpiSetColor( (HPS)GetHPS()
1532 ,m_textForegroundColour.GetPixel()
1533 );
1534 }
1535 if (m_textBackgroundColour.Ok())
1536 {
1537 ::GpiSetBackColor( (HPS)GetHPS()
1538 ,m_textBackgroundColour.GetPixel()
1539 );
1540 }
1541 //
1542 // Need to alter bits in a mono bitmap to match the new
1543 // background-foreground if it is different.
1544 //
1545 if (rBmp.IsMono() &&
1546 ((m_textForegroundColour.GetPixel() != lOldForeGround) ||
1547 (m_textBackgroundColour.GetPixel() != lOldBackGround)))
1548 {
1549 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1550 SIZEL vSize = {0, 0};
1551 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1552 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
1553
1554 int nBytesPerLine = rBmp.GetWidth() * 3;
1555 int i, j;
1556 LONG lForeGround = m_textForegroundColour.GetPixel();
1557 LONG lBackGround = m_textBackgroundColour.GetPixel();
1558 LONG lScans;
1559 HBITMAP hOldBitmap = NULLHANDLE;
1560 BITMAPINFO2 vInfo;
1561 ERRORID vError;
1562 wxString sError;
1563
1564
1565 memset(&vInfo, '\0', 16);
1566 vInfo.cbFix = 16;
1567 vInfo.cx = (ULONG)rBmp.GetWidth();
1568 vInfo.cy = (ULONG)rBmp.GetHeight();
1569 vInfo.cPlanes = 1;
1570 vInfo.cBitCount = 24;
1571
1572 unsigned char* pucBits; // buffer that will contain the bitmap data
1573 unsigned char* pucData; // pointer to use to traverse bitmap data
1574
1575 pucBits = new unsigned char[nBytesPerLine * rBmp.GetHeight()];
1576 memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
1577
1578 if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
1579 {
1580 vError = ::WinGetLastError(vHabmain);
1581 sError = wxPMErrorToStr(vError);
1582 return;
1583 }
1584 if ((lScans = ::GpiQueryBitmapBits( hPS
1585 ,0L
1586 ,(LONG)rBmp.GetHeight()
1587 ,(PBYTE)pucBits
1588 ,&vInfo
1589 )) == GPI_ALTERROR)
1590 {
1591 vError = ::WinGetLastError(vHabmain);
1592 sError = wxPMErrorToStr(vError);
1593 return;
1594 }
1595 unsigned char cOldRedFore = (unsigned char)(lOldForeGround >> 16);
1596 unsigned char cOldGreenFore = (unsigned char)(lOldForeGround >> 8);
1597 unsigned char cOldBlueFore = (unsigned char)lOldForeGround;
1598
1599 unsigned char cRedFore = (unsigned char)(lForeGround >> 16);
1600 unsigned char cGreenFore = (unsigned char)(lForeGround >> 8);
1601 unsigned char cBlueFore = (unsigned char)lForeGround;
1602
1603 unsigned char cRedBack = (unsigned char)(lBackGround >> 16);
1604 unsigned char cGreenBack = (unsigned char)(lBackGround >> 8);
1605 unsigned char cBlueBack = (unsigned char)lBackGround;
1606
1607 pucData = pucBits;
1608 for (i = 0; i < rBmp.GetHeight(); i++)
1609 {
1610 for (j = 0; j < rBmp.GetWidth(); j++)
1611 {
1612 unsigned char cBmpRed = *pucData;
1613 unsigned char cBmpGreen = *(pucData + 1);
1614 unsigned char cBmpBlue = *(pucData + 2);
1615
1616 if ((cBmpRed == cOldRedFore) &&
1617 (cBmpGreen == cOldGreenFore) &&
1618 (cBmpBlue == cOldBlueFore))
1619 {
1620 *pucData = cBlueFore;
1621 pucData++;
1622 *pucData = cGreenFore;
1623 pucData++;
1624 *pucData = cRedFore;
1625 pucData++;
1626 }
1627 else
1628 {
1629 *pucData = cBlueBack;
1630 pucData++;
1631 *pucData = cGreenBack;
1632 pucData++;
1633 *pucData = cRedBack;
1634 pucData++;
1635 }
1636 }
1637 }
1638 if ((lScans = ::GpiSetBitmapBits( hPS
1639 ,0L
1640 ,(LONG)rBmp.GetHeight()
1641 ,(PBYTE)pucBits
1642 ,&vInfo
1643 )) == GPI_ALTERROR)
1644 {
1645 vError = ::WinGetLastError(vHabmain);
1646 sError = wxPMErrorToStr(vError);
1647 return;
1648 }
1649 delete [] pucBits;
1650 ::GpiSetBitmap(hPS, NULLHANDLE);
1651 ::GpiDestroyPS(hPS);
1652 ::DevCloseDC(hDC);
1653 }
1654 ::GpiWCBitBlt( (HPS)GetHPS()
1655 ,hBitmap
1656 ,4
1657 ,vPoint
1658 ,ROP_SRCCOPY
1659 ,BBO_IGNORE
1660 );
1661 ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
1662 ::GpiSetColor((HPS)GetHPS(), lOldForeGround);
1663 ::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
1664 }
1665 }
1666 } // end of wxPMDCImpl::DoDrawBitmap
1667
1668 void wxPMDCImpl::DoDrawText(
1669 const wxString& rsText
1670 , wxCoord vX
1671 , wxCoord vY
1672 )
1673 {
1674 wxCoord vWidth;
1675 wxCoord vHeight;
1676
1677 DrawAnyText( rsText
1678 ,vX
1679 ,vY
1680 );
1681
1682 CalcBoundingBox(vX, vY);
1683 GetOwner()->GetTextExtent(rsText, &vWidth, &vHeight);
1684 CalcBoundingBox((vX + vWidth), (vY + vHeight));
1685 } // end of wxPMDCImpl::DoDrawText
1686
1687 void wxPMDCImpl::DrawAnyText( const wxString& rsText,
1688 wxCoord vX,
1689 wxCoord vY )
1690 {
1691 int nOldBackground = 0;
1692 POINTL vPtlStart;
1693 LONG lHits;
1694 wxCoord vTextX = 0;
1695 wxCoord vTextY = 0;
1696
1697 //
1698 // prepare for drawing the text
1699 //
1700
1701 //
1702 // Set text color attributes
1703 //
1704 if (m_textForegroundColour.Ok())
1705 {
1706 SetTextColor( m_hPS
1707 ,(int)m_textForegroundColour.GetPixel()
1708 );
1709 }
1710
1711 if (m_textBackgroundColour.Ok())
1712 {
1713 nOldBackground = SetTextBkColor( m_hPS
1714 ,(int)m_textBackgroundColour.GetPixel()
1715 );
1716 }
1717 SetBkMode( m_hPS
1718 ,m_backgroundMode
1719 );
1720 GetOwner()->GetTextExtent( rsText
1721 ,&vTextX
1722 ,&vTextY
1723 );
1724 vPtlStart.x = vX;
1725 if (!(m_vRclPaint.yTop == 0 &&
1726 m_vRclPaint.yBottom == 0 &&
1727 m_vRclPaint.xRight == 0 &&
1728 m_vRclPaint.xLeft == 0))
1729 {
1730 vPtlStart.y = OS2Y(vY,vTextY);
1731 }
1732 else
1733 {
1734 if (m_vSelectedBitmap.Ok())
1735 {
1736 m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
1737 m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
1738 vPtlStart.y = OS2Y(vY,vTextY);
1739 }
1740 else
1741 vPtlStart.y = vY;
1742 }
1743
1744 ::GpiMove(m_hPS, &vPtlStart);
1745 lHits = ::GpiCharString( m_hPS
1746 ,rsText.length()
1747 ,rsText.char_str()
1748 );
1749 if (lHits != GPI_OK)
1750 {
1751 wxLogLastError(wxT("TextOut"));
1752 }
1753
1754 //
1755 // Restore the old parameters (text foreground colour may be left because
1756 // it never is set to anything else, but background should remain
1757 // transparent even if we just drew an opaque string)
1758 //
1759 if (m_textBackgroundColour.Ok())
1760 SetTextBkColor( m_hPS
1761 ,nOldBackground
1762 );
1763 SetBkMode( m_hPS
1764 ,wxTRANSPARENT
1765 );
1766 }
1767
1768 void wxPMDCImpl::DoDrawRotatedText(
1769 const wxString& rsText
1770 , wxCoord vX
1771 , wxCoord vY
1772 , double dAngle
1773 )
1774 {
1775 if (dAngle == 0.0)
1776 {
1777 DoDrawText( rsText
1778 ,vX
1779 ,vY
1780 );
1781 }
1782
1783 // TODO:
1784 /*
1785 if ( angle == 0.0 )
1786 {
1787 DoDrawText(text, x, y);
1788 }
1789 else
1790 {
1791 LOGFONT lf;
1792 wxFillLogFont(&lf, &m_font);
1793
1794 // GDI wants the angle in tenth of degree
1795 long angle10 = (long)(angle * 10);
1796 lf.lfEscapement = angle10;
1797 lf. lfOrientation = angle10;
1798
1799 HFONT hfont = ::CreateFontIndirect(&lf);
1800 if ( !hfont )
1801 {
1802 wxLogLastError("CreateFont");
1803 }
1804 else
1805 {
1806 HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
1807
1808 DrawAnyText(text, x, y);
1809
1810 (void)::SelectObject(GetHdc(), hfontOld);
1811 }
1812
1813 // call the bounding box by adding all four vertices of the rectangle
1814 // containing the text to it (simpler and probably not slower than
1815 // determining which of them is really topmost/leftmost/...)
1816 wxCoord w, h;
1817 GetTextExtent(text, &w, &h);
1818
1819 double rad = DegToRad(angle);
1820
1821 // "upper left" and "upper right"
1822 CalcBoundingBox(x, y);
1823 CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
1824 CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
1825
1826 // "bottom left" and "bottom right"
1827 x += (wxCoord)(h*sin(rad));
1828 y += (wxCoord)(h*cos(rad));
1829 CalcBoundingBox(x, y);
1830 CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
1831 }
1832 */
1833 }
1834
1835 // ---------------------------------------------------------------------------
1836 // set GDI objects
1837 // ---------------------------------------------------------------------------
1838
1839 void wxPMDCImpl::DoSelectPalette( bool WXUNUSED(bRealize) )
1840 {
1841 //
1842 // Set the old object temporarily, in case the assignment deletes an object
1843 // that's not yet selected out.
1844 //
1845 if (m_hOldPalette)
1846 {
1847 m_hOldPalette = 0;
1848 }
1849
1850 if (m_palette.Ok())
1851 {
1852 HPALETTE hOldPal;
1853
1854 hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
1855 if (!m_hOldPalette)
1856 m_hOldPalette = (WXHPALETTE)hOldPal;
1857 }
1858 } // end of wxPMDCImpl::DoSelectPalette
1859
1860 void wxPMDCImpl::InitializePalette()
1861 {
1862 if (wxDisplayDepth() <= 8 )
1863 {
1864 //
1865 // Look for any window or parent that has a custom palette. If any has
1866 // one then we need to use it in drawing operations
1867 //
1868 wxWindow* pWin = m_pCanvas->GetAncestorWithCustomPalette();
1869
1870 m_hasCustomPalette = pWin && pWin->HasCustomPalette();
1871 if (m_hasCustomPalette)
1872 {
1873 m_palette = pWin->GetPalette();
1874
1875 //
1876 // turn on PM translation for this palette
1877 //
1878 DoSelectPalette();
1879 }
1880 }
1881 } // end of wxPMDCImpl::InitializePalette
1882
1883 void wxPMDCImpl::SetPalette(
1884 const wxPalette& rPalette
1885 )
1886 {
1887 if (m_hOldFont)
1888 {
1889 m_hOldFont = 0;
1890 }
1891 m_palette = rPalette;
1892 if (!rPalette.Ok())
1893 {
1894 if (m_hOldFont)
1895 {
1896 m_hOldFont = 0;
1897 }
1898 }
1899 HPALETTE hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
1900 if (!m_hOldPalette)
1901 m_hOldPalette = (WXHPALETTE)hOldPal;
1902 } // end of wxPMDCImpl::SetPalette
1903
1904 void wxPMDCImpl::SetFont(
1905 const wxFont& rFont
1906 )
1907 {
1908 //
1909 // Set the old object temporarily, in case the assignment deletes an object
1910 // that's not yet selected out.
1911 //
1912 if (m_hOldFont)
1913 {
1914 m_hOldFont = 0;
1915 }
1916 m_font = rFont;
1917 if (!rFont.Ok())
1918 {
1919 m_hOldFont = 0;
1920 }
1921
1922 m_font.SetPS(m_hPS); // this will realize the font
1923
1924 if (m_font.Ok())
1925 {
1926 HFONT hFont = m_font.GetResourceHandle();
1927 if (hFont == (HFONT) NULL)
1928 {
1929 wxLogDebug(wxT("::SelectObject failed in wxPMDCImpl::SetFont."));
1930 }
1931 if (!m_hOldFont)
1932 m_hOldFont = (WXHFONT) hFont;
1933 }
1934 } // end of wxPMDCImpl::SetFont
1935
1936 void wxPMDCImpl::SetPen(
1937 const wxPen& rPen
1938 )
1939 {
1940 if (m_pen == rPen)
1941 return;
1942 m_pen = rPen;
1943 if (!m_pen.Ok())
1944 return;
1945
1946 if (m_hOldPen)
1947 m_hOldPen = 0L;
1948 m_pen = rPen;
1949
1950 if (!m_pen.Ok())
1951 {
1952 if (m_hOldPen)
1953 {
1954 m_pen.SetPS((HPS)m_hOldPen);
1955 }
1956 m_hOldPen = 0L;
1957 }
1958
1959 if (m_pen.Ok())
1960 {
1961 if (m_pen.GetResourceHandle())
1962 {
1963 m_pen.SetPS(m_hPS);
1964 if (!m_hOldPen)
1965 m_hOldPen = m_pen.GetPS();
1966 }
1967 ::GpiSetColor(m_hPS, m_pen.GetColour().GetPixel());
1968 }
1969 }
1970
1971 void wxPMDCImpl::SetBrush(
1972 const wxBrush& rBrush
1973 )
1974 {
1975 if (m_hOldBrush)
1976 m_hOldBrush = 0L;
1977 m_brush = rBrush;
1978 if (!m_brush.Ok())
1979 if (m_brush == rBrush)
1980 return;
1981 if (!m_brush.Ok())
1982 if (m_hOldBrush)
1983 m_hOldBrush = 0L;
1984
1985 if (!m_brush.Ok())
1986 {
1987 if (m_hOldBrush)
1988 {
1989 m_brush.SetPS((HPS)m_hOldBrush);
1990 }
1991 m_hOldBrush = 0L;
1992 }
1993
1994 if (m_brush.Ok())
1995 {
1996 if (m_brush.GetResourceHandle())
1997 {
1998 m_brush.SetPS(m_hPS);
1999 if (!m_hOldBrush)
2000 m_hOldBrush = (WXHWND)m_brush.GetPS();
2001 }
2002 }
2003 } // end of wxPMDCImpl::SetBrush
2004
2005 void wxPMDCImpl::SetBackground(const wxBrush& rBrush)
2006 {
2007 m_backgroundBrush = rBrush;
2008
2009 if (m_backgroundBrush.Ok())
2010 {
2011 (void)::GpiSetBackColor((HPS)m_hPS, m_backgroundBrush.GetColour().GetPixel());
2012 }
2013 } // end of wxPMDCImpl::SetBackground
2014
2015 void wxPMDCImpl::SetBackgroundMode(int nMode)
2016 {
2017 m_backgroundMode = nMode;
2018 } // end of wxPMDCImpl::SetBackgroundMode
2019
2020 void wxPMDCImpl::SetLogicalFunction(wxRasterOperationMode nFunction)
2021 {
2022 m_logicalFunction = nFunction;
2023 SetRop((WXHDC)m_hDC);
2024 } // wxPMDCImpl::SetLogicalFunction
2025
2026 void wxPMDCImpl::SetRop(WXHDC hDC)
2027 {
2028 if (!hDC || m_logicalFunction < 0)
2029 return;
2030
2031 LONG lCRop;
2032 switch (m_logicalFunction)
2033 {
2034 case wxXOR:
2035 lCRop = FM_XOR;
2036 break;
2037
2038 case wxINVERT:
2039 lCRop = FM_INVERT;
2040 break;
2041
2042 case wxOR_REVERSE:
2043 lCRop = FM_MERGESRCNOT;
2044 break;
2045
2046 case wxAND_REVERSE:
2047 lCRop = FM_NOTMASKSRC;
2048 break;
2049
2050 case wxCLEAR:
2051 lCRop = FM_ONE;
2052 break;
2053
2054 case wxSET:
2055 lCRop = FM_ZERO;
2056 break;
2057
2058 case wxSRC_INVERT:
2059 lCRop = FM_MERGENOTSRC;
2060 break;
2061
2062 case wxOR_INVERT:
2063 lCRop = FM_MERGESRCNOT;
2064 break;
2065
2066 case wxAND:
2067 lCRop = FM_AND;
2068 break;
2069
2070 case wxOR:
2071 lCRop = FM_OR;
2072 break;
2073
2074 case wxAND_INVERT:
2075 lCRop = FM_SUBTRACT;
2076 break;
2077
2078 case wxEQUIV:
2079 case wxNAND:
2080 case wxCOPY:
2081 default:
2082 lCRop = FM_OVERPAINT;
2083 break;
2084 }
2085 ::GpiSetMix((HPS)hDC, lCRop);
2086 } // end of wxPMDCImpl::SetRop
2087
2088 bool wxPMDCImpl::StartDoc( const wxString& WXUNUSED(rsMessage) )
2089 {
2090 // We might be previewing, so return true to let it continue.
2091 return true;
2092 } // end of wxPMDCImpl::StartDoc
2093
2094 void wxPMDCImpl::EndDoc()
2095 {
2096 } // end of wxPMDCImpl::EndDoc
2097
2098 void wxPMDCImpl::StartPage()
2099 {
2100 } // end of wxPMDCImpl::StartPage
2101
2102 void wxPMDCImpl::EndPage()
2103 {
2104 } // end of wxPMDCImpl::EndPage
2105
2106 // ---------------------------------------------------------------------------
2107 // text metrics
2108 // ---------------------------------------------------------------------------
2109
2110 wxCoord wxPMDCImpl::GetCharHeight() const
2111 {
2112 FONTMETRICS vFM; // metrics structure
2113
2114 ::GpiQueryFontMetrics( m_hPS
2115 ,sizeof(FONTMETRICS)
2116 ,&vFM
2117 );
2118 return YDEV2LOGREL(vFM.lXHeight);
2119 }
2120
2121 wxCoord wxPMDCImpl::GetCharWidth() const
2122 {
2123 FONTMETRICS vFM; // metrics structure
2124
2125 ::GpiQueryFontMetrics( m_hPS
2126 ,sizeof(FONTMETRICS)
2127 ,&vFM
2128 );
2129 return XDEV2LOGREL(vFM.lAveCharWidth);
2130 }
2131
2132 void wxPMDCImpl::DoGetTextExtent(
2133 const wxString& rsString
2134 , wxCoord* pvX
2135 , wxCoord* pvY
2136 , wxCoord* pvDescent
2137 , wxCoord* pvExternalLeading
2138 , const wxFont* pTheFont
2139 ) const
2140 {
2141 POINTL avPoint[TXTBOX_COUNT];
2142 POINTL vPtMin;
2143 POINTL vPtMax;
2144 int i;
2145 int l;
2146 FONTMETRICS vFM; // metrics structure
2147 BOOL bRc;
2148 ERRORID vErrorCode; // last error id code
2149 wxFont* pFontToUse = (wxFont*)pTheFont;
2150
2151 wxChar zMsg[128]; // DEBUG
2152 wxString sError;
2153
2154 if (!pFontToUse)
2155 pFontToUse = (wxFont*)&m_font;
2156 l = rsString.length();
2157
2158 //
2159 // In world coordinates.
2160 //
2161 if (!m_hPS)
2162 {
2163 (void)wxMessageBox( _T("wxWidgets core library")
2164 ,"Using uninitialized DC for measuring text!\n"
2165 ,wxICON_INFORMATION
2166 );
2167 }
2168
2169 bRc = ::GpiQueryTextBox( m_hPS
2170 ,l
2171 ,rsString.char_str()
2172 ,TXTBOX_COUNT // return maximum information
2173 ,avPoint // array of coordinates points
2174 );
2175 if(!bRc)
2176 {
2177 vErrorCode = ::WinGetLastError(wxGetInstance());
2178 sError = wxPMErrorToStr(vErrorCode);
2179 // DEBUG
2180 wxSprintf(zMsg, _T("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
2181 (void)wxMessageBox( _T("wxWidgets core library")
2182 ,zMsg
2183 ,wxICON_INFORMATION
2184 );
2185 }
2186
2187 vPtMin.x = avPoint[0].x;
2188 vPtMax.x = avPoint[0].x;
2189 vPtMin.y = avPoint[0].y;
2190 vPtMax.y = avPoint[0].y;
2191 for (i = 1; i < 4; i++)
2192 {
2193 if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
2194 if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
2195 if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
2196 if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
2197 }
2198 ::GpiQueryFontMetrics( m_hPS
2199 ,sizeof(FONTMETRICS)
2200 ,&vFM
2201 );
2202
2203 if (pvX)
2204 *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
2205 if (pvY)
2206 *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
2207 if (pvDescent)
2208 *pvDescent = vFM.lMaxDescender;
2209 if (pvExternalLeading)
2210 *pvExternalLeading = vFM.lExternalLeading;
2211 }
2212
2213 void wxPMDCImpl::SetMapMode(
2214 wxMappingMode nMode
2215 )
2216 {
2217 int nPixelWidth = 0;
2218 int nPixelHeight = 0;
2219 int nMmWidth = 1;
2220 int nMmHeight = 1;
2221 LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
2222
2223 m_mappingMode = nMode;
2224
2225 if(::DevQueryCaps( m_hDC
2226 ,CAPS_FAMILY // id of first item
2227 ,CAPS_VERTICAL_RESOLUTION+1 // number of items wanted
2228 ,lArray
2229 ))
2230 {
2231 LONG lHorzRes;
2232 LONG lVertRes;
2233
2234 nPixelWidth = lArray[CAPS_WIDTH];
2235 nPixelHeight = lArray[CAPS_HEIGHT];
2236 lHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
2237 lVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
2238 nMmWidth = (lHorzRes/1000) * nPixelWidth;
2239 nMmHeight = (lVertRes/1000) * nPixelHeight;
2240 }
2241 if ((nPixelWidth == 0) || (nPixelHeight == 0) || (nMmWidth == 0) || (nMmHeight == 0))
2242 {
2243 return;
2244 }
2245
2246 double dMm2pixelsX = nPixelWidth/(double)nMmWidth;
2247 double dMm2pixelsY = nPixelHeight/(double)nMmHeight;
2248
2249 switch (nMode)
2250 {
2251 case wxMM_TWIPS:
2252 m_logicalScaleX = (twips2mm * dMm2pixelsX);
2253 m_logicalScaleY = (twips2mm * dMm2pixelsY);
2254 break;
2255
2256 case wxMM_POINTS:
2257 m_logicalScaleX = (pt2mm * dMm2pixelsX);
2258 m_logicalScaleY = (pt2mm * dMm2pixelsY);
2259 break;
2260
2261 case wxMM_METRIC:
2262 m_logicalScaleX = dMm2pixelsX;
2263 m_logicalScaleY = dMm2pixelsY;
2264 break;
2265
2266 case wxMM_LOMETRIC:
2267 m_logicalScaleX = (dMm2pixelsX/10.0);
2268 m_logicalScaleY = (dMm2pixelsY/10.0);
2269 break;
2270
2271 case wxMM_TEXT:
2272 default:
2273 m_logicalScaleX = 1.0;
2274 m_logicalScaleY = 1.0;
2275 break;
2276 }
2277
2278 SIZEL vSize;
2279 ULONG ulOptions;
2280
2281 ulOptions = ::GpiQueryPS(m_hPS, &vSize);
2282 if (!ulOptions & PU_ARBITRARY)
2283 {
2284 ulOptions = PU_ARBITRARY | GPIF_DEFAULT;
2285 ::GpiSetPS(m_hPS, &vSize, ulOptions);
2286 }
2287 ComputeScaleAndOrigin();
2288
2289 }; // end of wxPMDCImpl::SetMapMode
2290
2291 void wxPMDCImpl::SetUserScale( double dX,
2292 double dY )
2293 {
2294 m_userScaleX = dX;
2295 m_userScaleY = dY;
2296
2297 SetMapMode(m_mappingMode);
2298 } // end of wxPMDCImpl::SetUserScale
2299
2300 void wxPMDCImpl::SetAxisOrientation( bool bXLeftRight,
2301 bool bYBottomUp )
2302 {
2303 m_signX = bXLeftRight ? 1 : -1;
2304 m_signY = bYBottomUp ? -1 : 1;
2305
2306 SetMapMode(m_mappingMode);
2307 } // end of wxPMDCImpl::SetAxisOrientation
2308
2309 void wxPMDCImpl::SetLogicalOrigin(
2310 wxCoord vX
2311 , wxCoord vY
2312 )
2313 {
2314 RECTL vRect;
2315
2316 ::GpiQueryPageViewport( m_hPS
2317 ,&vRect
2318 );
2319 vRect.xRight -= vX;
2320 vRect.yTop += vY;
2321 vRect.xLeft = vX;
2322 vRect.yBottom = vY;
2323 ::GpiSetPageViewport( m_hPS
2324 ,&vRect
2325 );
2326 }; // end of wxPMDCImpl::SetLogicalOrigin
2327
2328 void wxPMDCImpl::SetDeviceOrigin(
2329 wxCoord vX
2330 , wxCoord vY
2331 )
2332 {
2333 RECTL vRect;
2334
2335 m_deviceOriginX = vX;
2336 m_deviceOriginY = vY;
2337 ::GpiQueryPageViewport( m_hPS
2338 ,&vRect
2339 );
2340 vRect.xLeft += vX;
2341 vRect.xRight += vX;
2342 vRect.yBottom -= vY;
2343 vRect.yTop -= vY;
2344 ::GpiSetPageViewport( m_hPS
2345 ,&vRect
2346 );
2347 }; // end of wxPMDCImpl::SetDeviceOrigin
2348
2349 // ---------------------------------------------------------------------------
2350 // bit blit
2351 // ---------------------------------------------------------------------------
2352
2353 bool wxPMDCImpl::DoBlit( wxCoord vXdest,
2354 wxCoord vYdest,
2355 wxCoord vWidth,
2356 wxCoord vHeight,
2357 wxDC* pSource,
2358 wxCoord vXsrc,
2359 wxCoord vYsrc,
2360 wxRasterOperationMode nRop,
2361 bool bUseMask,
2362 wxCoord WXUNUSED(vXsrcMask),
2363 wxCoord WXUNUSED(vYsrcMask) )
2364 {
2365 wxMask* pMask = NULL;
2366 CHARBUNDLE vCbnd;
2367 COLORREF vOldTextColor;
2368 COLORREF vOldBackground = ::GpiQueryBackColor(m_hPS);
2369
2370 wxDCImpl *impl = pSource->GetImpl();
2371 wxPMDCImpl *pm_impl = wxDynamicCast( impl, wxPMDCImpl );
2372 if (!pm_impl)
2373 {
2374 // TODO: Do we want to be able to blit
2375 // from other DCs too?
2376 return false;
2377 }
2378
2379 if (bUseMask)
2380 {
2381 const wxBitmap& rBmp = pm_impl->GetSelectedBitmap();
2382
2383 pMask = rBmp.GetMask();
2384 if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
2385 {
2386 bUseMask = false;
2387 }
2388 }
2389
2390 ::GpiQueryAttrs( m_hPS
2391 ,PRIM_CHAR
2392 ,CBB_COLOR
2393 ,&vCbnd
2394 );
2395 vOldTextColor = (COLORREF)vCbnd.lColor;
2396
2397 if (m_textForegroundColour.Ok())
2398 {
2399 vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
2400 ::GpiSetAttrs( m_hPS // presentation-space handle
2401 ,PRIM_CHAR // Char primitive.
2402 ,CBB_COLOR // sets color.
2403 ,0
2404 ,&vCbnd // buffer for attributes.
2405 );
2406 }
2407 if (m_textBackgroundColour.Ok())
2408 {
2409 ::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
2410 }
2411
2412 LONG lRop = ROP_SRCCOPY;
2413
2414 switch (nRop)
2415 {
2416 case wxXOR: lRop = ROP_SRCINVERT; break;
2417 case wxINVERT: lRop = ROP_DSTINVERT; break;
2418 case wxOR_REVERSE: lRop = 0x00DD0228; break;
2419 case wxAND_REVERSE: lRop = ROP_SRCERASE; break;
2420 case wxCLEAR: lRop = ROP_ZERO; break;
2421 case wxSET: lRop = ROP_ONE; break;
2422 case wxOR_INVERT: lRop = ROP_MERGEPAINT; break;
2423 case wxAND: lRop = ROP_SRCAND; break;
2424 case wxOR: lRop = ROP_SRCPAINT; break;
2425 case wxEQUIV: lRop = 0x00990066; break;
2426 case wxNAND: lRop = 0x007700E6; break;
2427 case wxAND_INVERT: lRop = 0x00220326; break;
2428 case wxCOPY: lRop = ROP_SRCCOPY; break;
2429 case wxNO_OP: lRop = ROP_NOTSRCERASE; break;
2430 case wxSRC_INVERT: lRop = ROP_SRCINVERT; break;
2431 case wxNOR: lRop = ROP_NOTSRCCOPY; break;
2432 default:
2433 wxFAIL_MSG( wxT("unsupported logical function") );
2434 return false;
2435 }
2436
2437 bool bSuccess;
2438
2439 if (bUseMask)
2440 {
2441 //
2442 // Blit bitmap with mask
2443 //
2444
2445 //
2446 // Create a temp buffer bitmap and DCs/PSs to access it and the mask
2447 //
2448 HDC hDCMask;
2449 HDC hDCBuffer;
2450 HPS hPSMask;
2451 HPS hPSBuffer;
2452 DEVOPENSTRUC vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
2453 BITMAPINFOHEADER2 vBmpHdr;
2454 HBITMAP hBufBitmap;
2455 SIZEL vSize = {0, 0};
2456 LONG rc;
2457
2458 memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
2459 vBmpHdr.cbFix = sizeof(BITMAPINFOHEADER2);
2460 vBmpHdr.cx = vWidth;
2461 vBmpHdr.cy = vHeight;
2462 vBmpHdr.cPlanes = 1;
2463 vBmpHdr.cBitCount = 24;
2464
2465 #if wxUSE_DC_CACHEING
2466 {
2467 //
2468 // create a temp buffer bitmap and DCs to access it and the mask
2469 //
2470 wxDCCacheEntry* pDCCacheEntry1 = FindDCInCache( NULL
2471 ,pm_impl->GetHPS()
2472 );
2473 wxDCCacheEntry* pDCCacheEntry2 = FindDCInCache( pDCCacheEntry1
2474 ,GetHPS()
2475 );
2476 wxDCCacheEntry* pBitmapCacheEntry = FindBitmapInCache( GetHPS()
2477 ,vWidth
2478 ,vHeight
2479 );
2480
2481 hPSMask = pDCCacheEntry1->m_hPS;
2482 hDCBuffer = (HDC)pDCCacheEntry2->m_hPS;
2483 hBufBitmap = (HBITMAP)pBitmapCacheEntry->m_hBitmap;
2484 wxUnusedVar(hDCMask);
2485 }
2486 #else
2487 {
2488 hDCMask = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
2489 hDCBuffer = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
2490 hPSMask = ::GpiCreatePS(vHabmain, hDCMask, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
2491 hPSBuffer = ::GpiCreatePS(vHabmain, hDCBuffer, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
2492 hBufBitmap = ::GpiCreateBitmap(GetHPS(), &vBmpHdr, 0L, NULL, NULL);
2493 }
2494 #endif
2495
2496 POINTL aPoint1[4] = { {0, 0}
2497 ,{vWidth, vHeight}
2498 ,{vXdest, vYdest}
2499 ,{vXdest + vWidth, vYdest + vHeight}
2500 };
2501 POINTL aPoint2[4] = { {0, 0}
2502 ,{vWidth, vHeight}
2503 ,{vXsrc, vYsrc}
2504 ,{vXsrc + vWidth, vYsrc + vHeight}
2505 };
2506 POINTL aPoint3[4] = { {vXdest, vYdest}
2507 ,{vXdest + vWidth, vYdest + vHeight}
2508 ,{vXsrc, vYsrc}
2509 ,{vXsrc + vWidth, vYsrc + vHeight}
2510 };
2511 POINTL aPoint4[4] = { {vXdest, vYdest}
2512 ,{vXdest + vWidth, vYdest + vHeight}
2513 ,{0, 0}
2514 ,{vWidth, vHeight}
2515 };
2516 ::GpiSetBitmap(hPSMask, (HBITMAP) pMask->GetMaskBitmap());
2517 ::GpiSetBitmap(hPSBuffer, (HBITMAP) hBufBitmap);
2518
2519 //
2520 // Copy dest to buffer
2521 //
2522 rc = ::GpiBitBlt( hPSBuffer
2523 ,GetHPS()
2524 ,4L
2525 ,aPoint1
2526 ,ROP_SRCCOPY
2527 ,BBO_IGNORE
2528 );
2529 if (rc == GPI_ERROR)
2530 {
2531 wxLogLastError(wxT("BitBlt"));
2532 }
2533
2534 //
2535 // Copy src to buffer using selected raster op
2536 //
2537 rc = ::GpiBitBlt( hPSBuffer
2538 ,GetHPS()
2539 ,4L
2540 ,aPoint2
2541 ,lRop
2542 ,BBO_IGNORE
2543 );
2544 if (rc == GPI_ERROR)
2545 {
2546 wxLogLastError(wxT("BitBlt"));
2547 }
2548
2549 //
2550 // Set masked area in buffer to BLACK (pixel value 0)
2551 //
2552 COLORREF vPrevBkCol = ::GpiQueryBackColor(GetHPS());
2553 COLORREF vPrevCol = ::GpiQueryColor(GetHPS());
2554
2555 ::GpiSetBackColor(GetHPS(), OS2RGB(255, 255, 255));
2556 ::GpiSetColor(GetHPS(), OS2RGB(0, 0, 0));
2557
2558 rc = ::GpiBitBlt( hPSBuffer
2559 ,hPSMask
2560 ,4L
2561 ,aPoint2
2562 ,ROP_SRCAND
2563 ,BBO_IGNORE
2564 );
2565 if (rc == GPI_ERROR)
2566 {
2567 wxLogLastError(wxT("BitBlt"));
2568 }
2569
2570 //
2571 // Set unmasked area in dest to BLACK
2572 //
2573 ::GpiSetBackColor(GetHPS(), OS2RGB(0, 0, 0));
2574 ::GpiSetColor(GetHPS(), OS2RGB(255, 255, 255));
2575 rc = ::GpiBitBlt( GetHPS()
2576 ,hPSMask
2577 ,4L
2578 ,aPoint3
2579 ,ROP_SRCAND
2580 ,BBO_IGNORE
2581 );
2582 if (rc == GPI_ERROR)
2583 {
2584 wxLogLastError(wxT("BitBlt"));
2585 }
2586
2587 //
2588 // Restore colours to original values
2589 //
2590 ::GpiSetBackColor(GetHPS(), vPrevBkCol);
2591 ::GpiSetColor(GetHPS(), vPrevCol);
2592
2593 //
2594 // OR buffer to dest
2595 //
2596 rc = ::GpiBitBlt( GetHPS()
2597 ,hPSMask
2598 ,4L
2599 ,aPoint4
2600 ,ROP_SRCPAINT
2601 ,BBO_IGNORE
2602 );
2603 if (rc == GPI_ERROR)
2604 {
2605 bSuccess = false;
2606 wxLogLastError(wxT("BitBlt"));
2607 }
2608
2609 //
2610 // Tidy up temporary DCs and bitmap
2611 //
2612 ::GpiSetBitmap(hPSMask, NULLHANDLE);
2613 ::GpiSetBitmap(hPSBuffer, NULLHANDLE);
2614 #if !wxUSE_DC_CACHEING
2615 ::GpiDestroyPS(hPSMask);
2616 ::GpiDestroyPS(hPSBuffer);
2617 ::DevCloseDC(hDCMask);
2618 ::DevCloseDC(hDCBuffer);
2619 ::GpiDeleteBitmap(hBufBitmap);
2620 #endif
2621 bSuccess = true;
2622 }
2623 else // no mask, just BitBlt() it
2624 {
2625 POINTL aPoint[4] = { {vXdest, vYdest}
2626 ,{vXdest + vWidth, vYdest + vHeight}
2627 ,{vXsrc, vYsrc}
2628 ,{vXsrc + vWidth, vYsrc + vHeight}
2629 };
2630
2631 bSuccess = (::GpiBitBlt( m_hPS
2632 ,pm_impl->GetHPS()
2633 ,4L
2634 ,aPoint
2635 ,lRop
2636 ,BBO_IGNORE
2637 ) != GPI_ERROR);
2638 if (!bSuccess )
2639 {
2640 wxLogLastError(wxT("BitBlt"));
2641 }
2642 }
2643 vCbnd.lColor = (LONG)vOldTextColor;
2644 ::GpiSetAttrs( m_hPS // presentation-space handle
2645 ,PRIM_CHAR // Char primitive.
2646 ,CBB_COLOR // sets color.
2647 ,0
2648 ,&vCbnd // buffer for attributes.
2649 );
2650 ::GpiSetBackColor(m_hPS, (LONG)vOldBackground);
2651 return bSuccess;
2652 }
2653
2654 void wxPMDCImpl::DoGetSize( int* pnWidth,
2655 int* pnHeight ) const
2656 {
2657 LONG lArray[CAPS_HEIGHT+1];
2658
2659 if(::DevQueryCaps( m_hDC
2660 ,CAPS_FAMILY
2661 ,CAPS_HEIGHT+1
2662 ,lArray
2663 ))
2664 {
2665 if (pnWidth)
2666 *pnWidth = lArray[CAPS_WIDTH];
2667 if (pnHeight)
2668 *pnHeight = lArray[CAPS_HEIGHT];
2669 }
2670 }; // end of wxPMDCImpl::DoGetSize(
2671
2672 void wxPMDCImpl::DoGetSizeMM( int* pnWidth,
2673 int* pnHeight ) const
2674 {
2675 LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
2676
2677 if(::DevQueryCaps( m_hDC
2678 ,CAPS_FAMILY
2679 ,CAPS_VERTICAL_RESOLUTION+1
2680 ,lArray
2681 ))
2682 {
2683 if(pnWidth)
2684 {
2685 int nWidth = lArray[CAPS_WIDTH];
2686 int nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
2687 // use fp to avoid returning 0 if nHorzRes < 1000
2688 *pnWidth = (int)((nHorzRes/1000.0) * nWidth);
2689 }
2690
2691 if(pnHeight)
2692 {
2693 int nHeight = lArray[CAPS_HEIGHT];
2694 int nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
2695 // use fp to avoid returning 0 if nVertRes < 1000
2696 *pnHeight = (int)((nVertRes/1000.0) * nHeight);
2697 }
2698 }
2699 }; // end of wxPMDCImpl::DoGetSizeMM
2700
2701 wxSize wxPMDCImpl::GetPPI() const
2702 {
2703 LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
2704 int nWidth = 0;
2705 int nHeight = 0;
2706
2707 if(::DevQueryCaps( m_hDC
2708 ,CAPS_FAMILY
2709 ,CAPS_VERTICAL_RESOLUTION+1
2710 ,lArray
2711 ))
2712 {
2713 int nPelWidth;
2714 int nPelHeight;
2715 int nHorzRes;
2716 int nVertRes;
2717
2718 nPelWidth = lArray[CAPS_WIDTH];
2719 nPelHeight = lArray[CAPS_HEIGHT];
2720 nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
2721 nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
2722 nWidth = (int)((nHorzRes/39.3) * nPelWidth);
2723 nHeight = (int)((nVertRes/39.3) * nPelHeight);
2724 }
2725 wxSize ppisize(nWidth, nHeight);
2726 return ppisize;
2727 } // end of wxPMDCImpl::GetPPI
2728
2729 void wxPMDCImpl::SetLogicalScale( double dX, double dY )
2730 {
2731 m_logicalScaleX = dX;
2732 m_logicalScaleY = dY;
2733 }; // end of wxPMDCImpl::SetLogicalScale
wxWidgets (Impactor)