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