src/os2/utilsgui.cpp

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