]> git.saurik.com Git - wxWidgets.git/blob - src/os2/utilsgui.cpp
cleanup - reformat (take 2)
[wxWidgets.git] / src / os2 / utilsgui.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: os2/utilsgui.cpp
3 // Purpose: Various utility functions only available in GUI
4 // Author: David Webster
5 // Modified by:
6 // Created: 20.08.2003 (extracted from os2/utils.cpp)
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // License: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/setup.h"
29 #include "wx/utils.h"
30 #include "wx/app.h"
31 #include "wx/cursor.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/apptrait.h"
35 #include "wx/timer.h"
36
37 #include "wx/os2/private.h" // includes <windows.h>
38
39 // ============================================================================
40 // implementation
41 // ============================================================================
42
43 // ----------------------------------------------------------------------------
44 // functions to work with .INI files
45 // ----------------------------------------------------------------------------
46
47 // Sleep for nSecs seconds. Attempt a Windows implementation using timers.
48 static bool inTimer = FALSE;
49
50 class wxSleepTimer: public wxTimer
51 {
52 public:
53 inline void Notify()
54 {
55 inTimer = FALSE;
56 Stop();
57 }
58 };
59
60 // Reading and writing resources (eg WIN.INI, .Xdefaults)
61 #if wxUSE_RESOURCES
62 bool wxWriteResource(
63 const wxString& rSection
64 , const wxString& rEntry
65 , const wxString& rValue
66 , const wxString& rFile
67 )
68 {
69 HAB hab = 0;
70 HINI hIni = 0;
71
72 if (rFile != "")
73 {
74 hIni = ::PrfOpenProfile(hab, (PSZ)WXSTRINGCAST rFile);
75 if (hIni != 0L)
76 {
77 return (::PrfWriteProfileString( hIni
78 ,(PSZ)WXSTRINGCAST rSection
79 ,(PSZ)WXSTRINGCAST rEntry
80 ,(PSZ)WXSTRINGCAST rValue
81 ));
82 }
83 }
84 else
85 return (::PrfWriteProfileString( HINI_PROFILE
86 ,(PSZ)WXSTRINGCAST rSection
87 ,(PSZ)WXSTRINGCAST rEntry
88 ,(PSZ)WXSTRINGCAST rValue
89 ));
90 return FALSE;
91 }
92
93 bool wxWriteResource(
94 const wxString& rSection
95 , const wxString& rEntry
96 , float fValue
97 , const wxString& rFile
98 )
99 {
100 wxChar zBuf[50];
101
102 wxSprintf(zBuf, "%.4f", fValue);
103 return wxWriteResource( rSection
104 ,rEntry
105 ,zBuf
106 ,rFile
107 );
108 }
109
110 bool wxWriteResource(
111 const wxString& rSection
112 , const wxString& rEntry
113 , long lValue
114 , const wxString& rFile
115 )
116 {
117 wxChar zBuf[50];
118
119 wxSprintf(zBuf, "%ld", lValue);
120 return wxWriteResource( rSection
121 ,rEntry
122 ,zBuf
123 ,rFile
124 );
125 }
126
127 bool wxWriteResource(
128 const wxString& rSection
129 , const wxString& rEntry
130 , int lValue
131 , const wxString& rFile
132 )
133 {
134 wxChar zBuf[50];
135
136 wxSprintf(zBuf, "%d", lValue);
137 return wxWriteResource( rSection
138 ,rEntry
139 ,zBuf
140 ,rFile
141 );
142 }
143
144 bool wxGetResource(
145 const wxString& rSection
146 , const wxString& rEntry
147 , wxChar** ppValue
148 , const wxString& rFile
149 )
150 {
151 HAB hab = 0;
152 HINI hIni = 0;
153 wxChar zDefunkt[] = _T("$$default");
154 char zBuf[1000];
155
156 if (rFile != "")
157 {
158 hIni = ::PrfOpenProfile(hab, (PSZ)WXSTRINGCAST rFile);
159 if (hIni != 0L)
160 {
161 ULONG n = ::PrfQueryProfileString( hIni
162 ,(PSZ)WXSTRINGCAST rSection
163 ,(PSZ)WXSTRINGCAST rEntry
164 ,(PSZ)zDefunkt
165 ,(PVOID)zBuf
166 ,1000
167 );
168 if (zBuf == NULL)
169 return FALSE;
170 if (n == 0L || wxStrcmp(zBuf, zDefunkt) == 0)
171 return FALSE;
172 zBuf[n-1] = '\0';
173 }
174 else
175 return FALSE;
176 }
177 else
178 {
179 ULONG n = ::PrfQueryProfileString( HINI_PROFILE
180 ,(PSZ)WXSTRINGCAST rSection
181 ,(PSZ)WXSTRINGCAST rEntry
182 ,(PSZ)zDefunkt
183 ,(PVOID)zBuf
184 ,1000
185 );
186 if (zBuf == NULL)
187 return FALSE;
188 if (n == 0L || wxStrcmp(zBuf, zDefunkt) == 0)
189 return FALSE;
190 zBuf[n-1] = '\0';
191 }
192 strcpy((char*)*ppValue, zBuf);
193 return TRUE;
194 }
195
196 bool wxGetResource(
197 const wxString& rSection
198 , const wxString& rEntry
199 , float* pValue
200 , const wxString& rFile
201 )
202 {
203 wxChar* zStr = NULL;
204
205 zStr = new wxChar[1000];
206 bool bSucc = wxGetResource( rSection
207 ,rEntry
208 ,(wxChar **)&zStr
209 ,rFile
210 );
211
212 if (bSucc)
213 {
214 *pValue = (float)wxStrtod(zStr, NULL);
215 delete[] zStr;
216 return TRUE;
217 }
218 else
219 {
220 delete[] zStr;
221 return FALSE;
222 }
223 }
224
225 bool wxGetResource(
226 const wxString& rSection
227 , const wxString& rEntry
228 , long* pValue
229 , const wxString& rFile
230 )
231 {
232 wxChar* zStr = NULL;
233
234 zStr = new wxChar[1000];
235 bool bSucc = wxGetResource( rSection
236 ,rEntry
237 ,(wxChar **)&zStr
238 ,rFile
239 );
240
241 if (bSucc)
242 {
243 *pValue = wxStrtol(zStr, NULL, 10);
244 delete[] zStr;
245 return TRUE;
246 }
247 else
248 {
249 delete[] zStr;
250 return FALSE;
251 }
252 }
253
254 bool wxGetResource(
255 const wxString& rSection
256 , const wxString& rEntry
257 , int* pValue
258 , const wxString& rFile
259 )
260 {
261 wxChar* zStr = NULL;
262
263 zStr = new wxChar[1000];
264 bool bSucc = wxGetResource( rSection
265 ,rEntry
266 ,(wxChar **)&zStr
267 ,rFile
268 );
269
270 if (bSucc)
271 {
272 *pValue = (int)wxStrtol(zStr, NULL, 10);
273 delete[] zStr;
274 return TRUE;
275 }
276 else
277 {
278 delete[] zStr;
279 return FALSE;
280 }
281 }
282 #endif // wxUSE_RESOURCES
283
284 // ---------------------------------------------------------------------------
285 // helper functions for showing a "busy" cursor
286 // ---------------------------------------------------------------------------
287
288 HCURSOR gs_wxBusyCursor = 0; // new, busy cursor
289 HCURSOR gs_wxBusyCursorOld = 0; // old cursor
290 static int gs_wxBusyCursorCount = 0;
291
292 // Set the cursor to the busy cursor for all windows
293 void wxBeginBusyCursor(
294 wxCursor* pCursor
295 )
296 {
297 if ( gs_wxBusyCursorCount++ == 0 )
298 {
299 gs_wxBusyCursor = (HCURSOR)pCursor->GetHCURSOR();
300 ::WinSetPointer(HWND_DESKTOP, (HPOINTER)gs_wxBusyCursor);
301 }
302 //else: nothing to do, already set
303 }
304
305 // Restore cursor to normal
306 void wxEndBusyCursor()
307 {
308 wxCHECK_RET( gs_wxBusyCursorCount > 0
309 ,_T("no matching wxBeginBusyCursor() for wxEndBusyCursor()")
310 );
311
312 if (--gs_wxBusyCursorCount == 0)
313 {
314 ::WinSetPointer(HWND_DESKTOP, (HPOINTER)gs_wxBusyCursorOld);
315 gs_wxBusyCursorOld = 0;
316 }
317 }
318
319 // TRUE if we're between the above two calls
320 bool wxIsBusy()
321 {
322 return (gs_wxBusyCursorCount > 0);
323 }
324
325 // Check whether this window wants to process messages, e.g. Stop button
326 // in long calculations.
327 bool wxCheckForInterrupt(
328 wxWindow* pWnd
329 )
330 {
331 if(pWnd)
332 {
333 QMSG vMsg;
334 HAB hab = 0;
335 HWND hwndFilter = NULLHANDLE;
336
337 while(::WinPeekMsg(hab, &vMsg, hwndFilter, 0, 0, PM_REMOVE))
338 {
339 ::WinDispatchMsg(hab, &vMsg);
340 }
341 return TRUE;//*** temporary?
342 }
343 else
344 {
345 wxFAIL_MSG(_T("pWnd==NULL !!!"));
346 return FALSE;//*** temporary?
347 }
348 }
349
350 // ----------------------------------------------------------------------------
351 // get display info
352 // ----------------------------------------------------------------------------
353
354 // See also the wxGetMousePosition in window.cpp
355 // Deprecated: use wxPoint wxGetMousePosition() instead
356 void wxGetMousePosition(
357 int* pX
358 , int* pY
359 )
360 {
361 POINTL vPt;
362
363 ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
364 *pX = vPt.x;
365 *pY = vPt.y;
366 };
367
368 // Return TRUE if we have a colour display
369 bool wxColourDisplay()
370 {
371 #if 0
372 HPS hpsScreen;
373 HDC hdcScreen;
374 LONG lColors;
375
376 hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
377 hdcScreen = ::GpiQueryDevice(hpsScreen);
378 ::DevQueryCaps(hdcScreen, CAPS_COLORS, 1L, &lColors);
379 return(lColors > 1L);
380 #else
381 // I don't see how the PM display could not be color. Besides, this
382 // was leaking DCs and PSs!!! MN
383 return TRUE;
384 #endif
385 }
386
387 // Returns depth of screen
388 int wxDisplayDepth()
389 {
390 HPS hpsScreen;
391 HDC hdcScreen;
392 LONG lPlanes;
393 LONG lBitsPerPixel;
394 static LONG nDepth = 0;
395
396 // The screen colordepth ain't gonna change. No reason to query
397 // it over and over!
398 if (!nDepth) {
399 hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
400 hdcScreen = ::GpiQueryDevice(hpsScreen);
401 ::DevQueryCaps(hdcScreen, CAPS_COLOR_PLANES, 1L, &lPlanes);
402 ::DevQueryCaps(hdcScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitsPerPixel);
403
404 nDepth = (int)(lPlanes * lBitsPerPixel);
405 ::DevCloseDC(hdcScreen);
406 ::WinReleasePS(hpsScreen);
407 }
408 return (nDepth);
409 }
410
411 // Get size of display
412 void wxDisplaySize(
413 int* pWidth
414 , int* pHeight
415 )
416 {
417 HPS hpsScreen;
418 HDC hdcScreen;
419 static LONG lWidth = 0;
420 static LONG lHeight = 0;
421
422 // The screen size ain't gonna change either so just cache the values
423 if (!lWidth) {
424 hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
425 hdcScreen = ::GpiQueryDevice(hpsScreen);
426 ::DevQueryCaps(hdcScreen, CAPS_WIDTH, 1L, &lWidth);
427 ::DevQueryCaps(hdcScreen, CAPS_HEIGHT, 1L, &lHeight);
428 ::DevCloseDC(hdcScreen);
429 ::WinReleasePS(hpsScreen);
430 }
431 if (pWidth)
432 *pWidth = (int)lWidth;
433 if (pHeight)
434 *pHeight = (int)lHeight;
435 }
436
437 void wxDisplaySizeMM(
438 int* pWidth
439 , int* pHeight
440 )
441 {
442 HPS hpsScreen;
443 HDC hdcScreen;
444
445 hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
446 hdcScreen = ::GpiQueryDevice(hpsScreen);
447
448 if (pWidth)
449 ::DevQueryCaps( hdcScreen
450 ,CAPS_HORIZONTAL_RESOLUTION
451 ,1L
452 ,(PLONG)pWidth
453 );
454 if (pHeight)
455 ::DevQueryCaps( hdcScreen
456 ,CAPS_VERTICAL_RESOLUTION
457 ,1L
458 ,(PLONG)pHeight
459 );
460 ::DevCloseDC(hdcScreen);
461 ::WinReleasePS(hpsScreen);
462 }
463
464 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
465 {
466 // This is supposed to return desktop dimensions minus any window
467 // manager panels, menus, taskbars, etc. If there is a way to do that
468 // for this platform please fix this function, otherwise it defaults
469 // to the entire desktop.
470 if (x) *x = 0;
471 if (y) *y = 0;
472 wxDisplaySize(width, height);
473 }
474
475 void wxGUIAppTraits::InitializeGui(unsigned long &ulHab)
476 {
477 ulHab = ::WinInitialize(0);
478 }
479
480 void wxGUIAppTraits::TerminateGui(unsigned long ulHab)
481 {
482 ::WinTerminate(ulHab);
483 }
484
485 wxToolkitInfo & wxGUIAppTraits::GetToolkitInfo()
486 {
487 static wxToolkitInfo vInfo;
488 ULONG ulSysInfo[QSV_MAX] = {0};
489 APIRET ulrc;
490
491 vInfo.shortName = _T("PM");
492 vInfo.name = _T("wxOS2");
493 #ifdef __WXUNIVERSAL__
494 vInfo.shortName << _T("univ");
495 vInfo.name << _T("/wxUniversal");
496 #endif
497 ulrc = ::DosQuerySysInfo( 1L
498 ,QSV_MAX
499 ,(PVOID)ulSysInfo
500 ,sizeof(ULONG) * QSV_MAX
501 );
502 if (ulrc == 0L)
503 {
504 vInfo.versionMajor = ulSysInfo[QSV_VERSION_MAJOR] / 10;
505 vInfo.versionMinor = ulSysInfo[QSV_VERSION_MINOR];
506 }
507 vInfo.os = wxOS2_PM;
508 return vInfo;
509 }
510
511 // ---------------------------------------------------------------------------
512 // window information functions
513 // ---------------------------------------------------------------------------
514
515 wxString WXDLLEXPORT wxGetWindowText(
516 WXHWND hWnd
517 )
518 {
519 wxString vStr;
520
521 if ( hWnd )
522 {
523 long lLen = ::WinQueryWindowTextLength((HWND)hWnd) + 1;
524 ::WinQueryWindowText((HWND)hWnd, lLen, (PSZ)(wxChar*)wxStringBuffer(vStr, lLen));
525 }
526
527 return vStr;
528 }
529
530 wxString WXDLLEXPORT wxGetWindowClass(
531 WXHWND hWnd
532 )
533 {
534 wxString vStr;
535 if ( hWnd )
536 {
537 int nLen = 256; // some starting value
538
539 for ( ;; )
540 {
541 int nCount = ::WinQueryClassName((HWND)hWnd, nLen, (PSZ)(wxChar*)wxStringBuffer(vStr, nLen));
542
543 if (nCount == nLen )
544 {
545 // the class name might have been truncated, retry with larger
546 // buffer
547 nLen *= 2;
548 }
549 else
550 {
551 break;
552 }
553 }
554 }
555 return vStr;
556 }
557
558 WXWORD WXDLLEXPORT wxGetWindowId(
559 WXHWND hWnd
560 )
561 {
562 return ::WinQueryWindowUShort((HWND)hWnd, QWS_ID);
563 }
564
565 void wxDrawBorder(
566 HPS hPS
567 , RECTL& rRect
568 , WXDWORD dwStyle
569 )
570 {
571 POINTL vPoint[2];
572
573 vPoint[0].x = rRect.xLeft;
574 vPoint[0].y = rRect.yBottom;
575 ::GpiMove(hPS, &vPoint[0]);
576 if (dwStyle & wxSIMPLE_BORDER ||
577 dwStyle & wxSTATIC_BORDER)
578 {
579 vPoint[1].x = rRect.xRight - 1;
580 vPoint[1].y = rRect.yTop - 1;
581 ::GpiBox( hPS
582 ,DRO_OUTLINE
583 ,&vPoint[1]
584 ,0L
585 ,0L
586 );
587 }
588 if (dwStyle & wxSUNKEN_BORDER)
589 {
590 LINEBUNDLE vLineBundle;
591
592 vLineBundle.lColor = 0x00FFFFFF; // WHITE
593 vLineBundle.usMixMode = FM_OVERPAINT;
594 vLineBundle.fxWidth = 2;
595 vLineBundle.lGeomWidth = 2;
596 vLineBundle.usType = LINETYPE_SOLID;
597 vLineBundle.usEnd = 0;
598 vLineBundle.usJoin = 0;
599 ::GpiSetAttrs( hPS
600 ,PRIM_LINE
601 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
602 ,0L
603 ,&vLineBundle
604 );
605 vPoint[1].x = rRect.xRight - 1;
606 vPoint[1].y = rRect.yTop - 1;
607 ::GpiBox( hPS
608 ,DRO_OUTLINE
609 ,&vPoint[1]
610 ,0L
611 ,0L
612 );
613 vPoint[0].x = rRect.xLeft + 1;
614 vPoint[0].y = rRect.yBottom + 1;
615 ::GpiMove(hPS, &vPoint[0]);
616 vPoint[1].x = rRect.xRight - 2;
617 vPoint[1].y = rRect.yTop - 2;
618 ::GpiBox( hPS
619 ,DRO_OUTLINE
620 ,&vPoint[1]
621 ,0L
622 ,0L
623 );
624
625 vLineBundle.lColor = 0x00000000; // BLACK
626 vLineBundle.usMixMode = FM_OVERPAINT;
627 vLineBundle.fxWidth = 2;
628 vLineBundle.lGeomWidth = 2;
629 vLineBundle.usType = LINETYPE_SOLID;
630 vLineBundle.usEnd = 0;
631 vLineBundle.usJoin = 0;
632 ::GpiSetAttrs( hPS
633 ,PRIM_LINE
634 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
635 ,0L
636 ,&vLineBundle
637 );
638 vPoint[0].x = rRect.xLeft + 2;
639 vPoint[0].y = rRect.yBottom + 2;
640 ::GpiMove(hPS, &vPoint[0]);
641 vPoint[1].x = rRect.xLeft + 2;
642 vPoint[1].y = rRect.yTop - 3;
643 ::GpiLine(hPS, &vPoint[1]);
644 vPoint[1].x = rRect.xRight - 3;
645 vPoint[1].y = rRect.yTop - 3;
646 ::GpiLine(hPS, &vPoint[1]);
647
648 vPoint[0].x = rRect.xLeft + 3;
649 vPoint[0].y = rRect.yBottom + 3;
650 ::GpiMove(hPS, &vPoint[0]);
651 vPoint[1].x = rRect.xLeft + 3;
652 vPoint[1].y = rRect.yTop - 4;
653 ::GpiLine(hPS, &vPoint[1]);
654 vPoint[1].x = rRect.xRight - 4;
655 vPoint[1].y = rRect.yTop - 4;
656 ::GpiLine(hPS, &vPoint[1]);
657 }
658 if (dwStyle & wxDOUBLE_BORDER)
659 {
660 LINEBUNDLE vLineBundle;
661
662 vLineBundle.lColor = 0x00FFFFFF; // WHITE
663 vLineBundle.usMixMode = FM_OVERPAINT;
664 vLineBundle.fxWidth = 2;
665 vLineBundle.lGeomWidth = 2;
666 vLineBundle.usType = LINETYPE_SOLID;
667 vLineBundle.usEnd = 0;
668 vLineBundle.usJoin = 0;
669 ::GpiSetAttrs( hPS
670 ,PRIM_LINE
671 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
672 ,0L
673 ,&vLineBundle
674 );
675 vPoint[1].x = rRect.xRight - 1;
676 vPoint[1].y = rRect.yTop - 1;
677 ::GpiBox( hPS
678 ,DRO_OUTLINE
679 ,&vPoint[1]
680 ,0L
681 ,0L
682 );
683 vLineBundle.lColor = 0x00000000; // WHITE
684 vLineBundle.usMixMode = FM_OVERPAINT;
685 vLineBundle.fxWidth = 2;
686 vLineBundle.lGeomWidth = 2;
687 vLineBundle.usType = LINETYPE_SOLID;
688 vLineBundle.usEnd = 0;
689 vLineBundle.usJoin = 0;
690 ::GpiSetAttrs( hPS
691 ,PRIM_LINE
692 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
693 ,0L
694 ,&vLineBundle
695 );
696 vPoint[0].x = rRect.xLeft + 2;
697 vPoint[0].y = rRect.yBottom + 2;
698 ::GpiMove(hPS, &vPoint[0]);
699 vPoint[1].x = rRect.xRight - 2;
700 vPoint[1].y = rRect.yTop - 2;
701 ::GpiBox( hPS
702 ,DRO_OUTLINE
703 ,&vPoint[1]
704 ,0L
705 ,0L
706 );
707 vLineBundle.lColor = 0x00FFFFFF; // BLACK
708 vLineBundle.usMixMode = FM_OVERPAINT;
709 vLineBundle.fxWidth = 2;
710 vLineBundle.lGeomWidth = 2;
711 vLineBundle.usType = LINETYPE_SOLID;
712 vLineBundle.usEnd = 0;
713 vLineBundle.usJoin = 0;
714 ::GpiSetAttrs( hPS
715 ,PRIM_LINE
716 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
717 ,0L
718 ,&vLineBundle
719 );
720 vPoint[0].x = rRect.xLeft + 3;
721 vPoint[0].y = rRect.yBottom + 3;
722 ::GpiMove(hPS, &vPoint[0]);
723 vPoint[1].x = rRect.xRight - 3;
724 vPoint[1].y = rRect.yTop - 3;
725 ::GpiBox( hPS
726 ,DRO_OUTLINE
727 ,&vPoint[1]
728 ,0L
729 ,0L
730 );
731 }
732 if (dwStyle & wxRAISED_BORDER)
733 {
734 LINEBUNDLE vLineBundle;
735
736 vLineBundle.lColor = 0x00000000; // BLACK
737 vLineBundle.usMixMode = FM_OVERPAINT;
738 vLineBundle.fxWidth = 2;
739 vLineBundle.lGeomWidth = 2;
740 vLineBundle.usType = LINETYPE_SOLID;
741 vLineBundle.usEnd = 0;
742 vLineBundle.usJoin = 0;
743 ::GpiSetAttrs( hPS
744 ,PRIM_LINE
745 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
746 ,0L
747 ,&vLineBundle
748 );
749 vPoint[1].x = rRect.xRight - 1;
750 vPoint[1].y = rRect.yTop - 1;
751 ::GpiBox( hPS
752 ,DRO_OUTLINE
753 ,&vPoint[1]
754 ,0L
755 ,0L
756 );
757 vPoint[0].x = rRect.xLeft + 1;
758 vPoint[0].y = rRect.yBottom + 1;
759 ::GpiMove(hPS, &vPoint[0]);
760 vPoint[1].x = rRect.xRight - 2;
761 vPoint[1].y = rRect.yTop - 2;
762 ::GpiBox( hPS
763 ,DRO_OUTLINE
764 ,&vPoint[1]
765 ,0L
766 ,0L
767 );
768
769 vLineBundle.lColor = 0x00FFFFFF; // WHITE
770 vLineBundle.usMixMode = FM_OVERPAINT;
771 vLineBundle.fxWidth = 2;
772 vLineBundle.lGeomWidth = 2;
773 vLineBundle.usType = LINETYPE_SOLID;
774 vLineBundle.usEnd = 0;
775 vLineBundle.usJoin = 0;
776 ::GpiSetAttrs( hPS
777 ,PRIM_LINE
778 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
779 ,0L
780 ,&vLineBundle
781 );
782 vPoint[0].x = rRect.xLeft + 2;
783 vPoint[0].y = rRect.yBottom + 2;
784 ::GpiMove(hPS, &vPoint[0]);
785 vPoint[1].x = rRect.xLeft + 2;
786 vPoint[1].y = rRect.yTop - 3;
787 ::GpiLine(hPS, &vPoint[1]);
788 vPoint[1].x = rRect.xRight - 3;
789 vPoint[1].y = rRect.yTop - 3;
790 ::GpiLine(hPS, &vPoint[1]);
791
792 vPoint[0].x = rRect.xLeft + 3;
793 vPoint[0].y = rRect.yBottom + 3;
794 ::GpiMove(hPS, &vPoint[0]);
795 vPoint[1].x = rRect.xLeft + 3;
796 vPoint[1].y = rRect.yTop - 4;
797 ::GpiLine(hPS, &vPoint[1]);
798 vPoint[1].x = rRect.xRight - 4;
799 vPoint[1].y = rRect.yTop - 4;
800 ::GpiLine(hPS, &vPoint[1]);
801 }
802 } // end of wxDrawBorder
803
804 void wxOS2SetFont(
805 HWND hWnd
806 , const wxFont& rFont
807 )
808 {
809 char zFont[128];
810 char zFacename[30];
811 char zWeight[30];
812 char zStyle[30];
813
814 if (hWnd == NULLHANDLE)
815 return;
816
817 //
818 // The fonts available for Presentation Params are just a few
819 // outline fonts, the rest are available to the GPI, so we must
820 // map the families to one of these three
821 //
822 switch(rFont.GetFamily())
823 {
824 case wxSCRIPT:
825 strcpy(zFacename, "Script");
826 break;
827
828 case wxDECORATIVE:
829 strcpy(zFacename, "WarpSans");
830 break;
831
832 case wxROMAN:
833 strcpy(zFacename,"Times New Roman");
834 break;
835
836 case wxTELETYPE:
837 strcpy(zFacename, "Courier New");
838 break;
839
840 case wxMODERN:
841 strcpy(zFacename, "Courier New");
842 break;
843
844 case wxDEFAULT:
845 default:
846 case wxSWISS:
847 strcpy(zFacename, "Helvetica");
848 break;
849 }
850
851 switch(rFont.GetWeight())
852 {
853 default:
854 case wxNORMAL:
855 case wxLIGHT:
856 zWeight[0] = '\0';
857 break;
858
859 case wxBOLD:
860 case wxFONTWEIGHT_MAX:
861 strcpy(zWeight, "Bold");
862 break;
863 }
864
865 switch(rFont.GetStyle())
866 {
867 case wxITALIC:
868 case wxSLANT:
869 strcpy(zStyle, "Italic");
870 break;
871
872 default:
873 zStyle[0] = '\0';
874 break;
875 }
876 sprintf(zFont, "%d.%s", rFont.GetPointSize(), zFacename);
877 if (zWeight[0] != '\0')
878 {
879 strcat(zFont, " ");
880 strcat(zFont, zWeight);
881 }
882 if (zStyle[0] != '\0')
883 {
884 strcat(zFont, " ");
885 strcat(zFont, zStyle);
886 }
887 ::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont) + 1, (PVOID)zFont);
888 } // end of wxOS2SetFont
889
890 // ---------------------------------------------------------------------------
891 // Helper for taking a regular bitmap and giving it a disabled look
892 // ---------------------------------------------------------------------------
893 wxBitmap wxDisableBitmap(
894 const wxBitmap& rBmp
895 , long lColor
896 )
897 {
898 wxMask* pMask = rBmp.GetMask();
899
900 if (!pMask)
901 return(wxNullBitmap);
902
903 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
904 SIZEL vSize = {0, 0};
905 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
906 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
907 BITMAPINFOHEADER2 vHeader;
908 BITMAPINFO2 vInfo;
909 ERRORID vError;
910 wxString sError;
911 HBITMAP hBitmap = (HBITMAP)rBmp.GetHBITMAP();
912 HBITMAP hOldBitmap = NULLHANDLE;
913 HBITMAP hOldMask = NULLHANDLE;
914 HBITMAP hMask = (HBITMAP)rBmp.GetMask()->GetMaskBitmap();
915 unsigned char* pucBits; // buffer that will contain the bitmap data
916 unsigned char* pucData; // pointer to use to traverse bitmap data
917 unsigned char* pucBitsMask; // buffer that will contain the mask data
918 unsigned char* pucDataMask; // pointer to use to traverse mask data
919 LONG lScans = 0L;
920 LONG lScansSet = 0L;
921 bool bpp16 = (wxDisplayDepth() == 16);
922
923 memset(&vHeader, '\0', 16);
924 vHeader.cbFix = 16;
925
926 memset(&vInfo, '\0', 16);
927 vInfo.cbFix = 16;
928 vInfo.cx = (ULONG)rBmp.GetWidth();
929 vInfo.cy = (ULONG)rBmp.GetHeight();
930 vInfo.cPlanes = 1;
931 vInfo.cBitCount = 24; // Set to desired count going in
932
933 //
934 // Create the buffers for data....all wxBitmaps are 24 bit internally
935 //
936 int nBytesPerLine = rBmp.GetWidth() * 3;
937 int nSizeDWORD = sizeof(DWORD);
938 int nLineBoundary = nBytesPerLine % nSizeDWORD;
939 int nPadding = 0;
940 int i;
941 int j;
942
943 //
944 // Bitmap must be in a double-word aligned address so we may
945 // have some padding to worry about
946 //
947 if (nLineBoundary > 0)
948 {
949 nPadding = nSizeDWORD - nLineBoundary;
950 nBytesPerLine += nPadding;
951 }
952 pucBits = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
953 memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
954 pucBitsMask = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
955 memset(pucBitsMask, '\0', (nBytesPerLine * rBmp.GetHeight()));
956
957 //
958 // Extract the bitmap and mask data
959 //
960 if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
961 {
962 vError = ::WinGetLastError(vHabmain);
963 sError = wxPMErrorToStr(vError);
964 }
965 ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
966 vInfo.cBitCount = 24;
967 if ((lScans = ::GpiQueryBitmapBits( hPS
968 ,0L
969 ,(LONG)rBmp.GetHeight()
970 ,(PBYTE)pucBits
971 ,&vInfo
972 )) == GPI_ALTERROR)
973 {
974 vError = ::WinGetLastError(vHabmain);
975 sError = wxPMErrorToStr(vError);
976 }
977 if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
978 {
979 vError = ::WinGetLastError(vHabmain);
980 sError = wxPMErrorToStr(vError);
981 }
982 ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
983 vInfo.cBitCount = 24;
984 if ((lScans = ::GpiQueryBitmapBits( hPS
985 ,0L
986 ,(LONG)rBmp.GetHeight()
987 ,(PBYTE)pucBitsMask
988 ,&vInfo
989 )) == GPI_ALTERROR)
990 {
991 vError = ::WinGetLastError(vHabmain);
992 sError = wxPMErrorToStr(vError);
993 }
994 if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
995 {
996 vError = ::WinGetLastError(vHabmain);
997 sError = wxPMErrorToStr(vError);
998 }
999 pucData = pucBits;
1000 pucDataMask = pucBitsMask;
1001
1002 //
1003 // Get the mask value
1004 //
1005 for (i = 0; i < rBmp.GetHeight(); i++)
1006 {
1007 for (j = 0; j < rBmp.GetWidth(); j++)
1008 {
1009 // Byte 1
1010 if (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
1011 {
1012 *pucData = 0x7F;
1013 pucData++;
1014 }
1015 else if (*pucDataMask == 0xFF) // set to grey
1016 {
1017 *pucData = 0x7F;
1018 pucData++;
1019 }
1020 else
1021 {
1022 *pucData = ((unsigned char)(lColor >> 16));
1023 pucData++;
1024 }
1025
1026 // Byte 2
1027 if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
1028 {
1029 *pucData = 0x7F;
1030 pucData++;
1031 }
1032 else if (*(pucDataMask + 1) == 0xFF) // set to grey
1033 {
1034 *pucData = 0x7F;
1035 pucData++;
1036 }
1037 else
1038 {
1039 *pucData = ((unsigned char)(lColor >> 8));
1040 pucData++;
1041 }
1042
1043 // Byte 3
1044 if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
1045 {
1046 *pucData = 0x7F;
1047 pucData++;
1048 }
1049 else if (*(pucDataMask + 2) == 0xFF) // set to grey
1050 {
1051 *pucData = 0x7F;
1052 pucData++;
1053 }
1054 else
1055 {
1056 *pucData = ((unsigned char)lColor);
1057 pucData++;
1058 }
1059 pucDataMask += 3;
1060 }
1061 for (j = 0; j < nPadding; j++)
1062 {
1063 pucData++;
1064 pucDataMask++;
1065 }
1066 }
1067
1068 //
1069 // Create a new bitmap and set the modified bits
1070 //
1071 wxBitmap vNewBmp( rBmp.GetWidth()
1072 ,rBmp.GetHeight()
1073 ,24
1074 );
1075 HBITMAP hNewBmp = (HBITMAP)vNewBmp.GetHBITMAP();
1076
1077 if ((hOldBitmap = ::GpiSetBitmap(hPS, hNewBmp)) == HBM_ERROR)
1078 {
1079 vError = ::WinGetLastError(vHabmain);
1080 sError = wxPMErrorToStr(vError);
1081 }
1082 if ((lScansSet = ::GpiSetBitmapBits( hPS
1083 ,0L
1084 ,(LONG)rBmp.GetHeight()
1085 ,(PBYTE)pucBits
1086 ,&vInfo
1087 )) == GPI_ALTERROR)
1088
1089 {
1090 vError = ::WinGetLastError(vHabmain);
1091 sError = wxPMErrorToStr(vError);
1092 }
1093 wxMask* pNewMask;
1094
1095 pNewMask = new wxMask(pMask->GetMaskBitmap());
1096 vNewBmp.SetMask(pNewMask);
1097 free(pucBits);
1098 ::GpiSetBitmap(hPS, NULLHANDLE);
1099 ::GpiDestroyPS(hPS);
1100 ::DevCloseDC(hDC);
1101 if (vNewBmp.Ok())
1102 return(vNewBmp);
1103 return(wxNullBitmap);
1104 } // end of wxDisableBitmap
1105
1106 COLORREF wxColourToRGB(
1107 const wxColour& rColor
1108 )
1109 {
1110 return(OS2RGB(rColor.Red(), rColor.Green(), rColor.Blue()));
1111 } // end of wxColourToRGB