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