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