src/os2/region.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // File:      src/os2/region.cpp
   3 // Purpose:   Region class
   4 // Author:    David Webster
   5 // Modified by:
   6 // Created:   10/15/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/app.h"
  17     #include "wx/window.h"
  18     #include "wx/gdicmn.h"
  19 #endif
  20
  21 #include "wx/os2/region.h"
  22
  23 #include "wx/os2/private.h"
  24
  25 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
  26 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
  27
  28 //-----------------------------------------------------------------------------
  29 // wxRegionRefData implementation
  30 //-----------------------------------------------------------------------------
  31
  32 class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
  33 public:
  34     wxRegionRefData()
  35     {
  36         m_hRegion = 0;
  37         m_hPS     = 0;
  38     }
  39
  40     wxRegionRefData(const wxRegionRefData& rData)
  41     {
  42         RGNRECT                     vRgnData;
  43         PRECTL                      pRect = NULL;
  44
  45         vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
  46         if (::GpiQueryRegionRects( rData.m_hPS      // Pres space
  47                                   ,rData.m_hRegion  // Handle of region to query
  48                                   ,NULL             // Return all RECTs
  49                                   ,&vRgnData        // Will contain number or RECTs in region
  50                                   ,NULL             // NULL to return number of RECTs
  51                                  ))
  52         {
  53             pRect = new RECTL[vRgnData.crcReturned];
  54             vRgnData.crc = vRgnData.crcReturned;
  55             vRgnData.ircStart = 1;
  56             if (::GpiQueryRegionRects( rData.m_hPS     // Pres space of source
  57                                       ,rData.m_hRegion // Handle of source region
  58                                       ,NULL            // Return all RECTs
  59                                       ,&vRgnData       // Operations set to return rects
  60                                       ,pRect           // Will contain the actual RECTS
  61                                      ))
  62             {
  63                 m_hRegion = ::GpiCreateRegion( rData.m_hPS
  64                                               ,vRgnData.crcReturned
  65                                               ,pRect
  66                                              );
  67                 m_hPS = rData.m_hPS;
  68             }
  69             delete [] pRect;
  70         }
  71     }
  72
  73     virtual ~wxRegionRefData()
  74     {
  75         ::GpiDestroyRegion(m_hPS, m_hRegion);
  76     }
  77
  78     HRGN                            m_hRegion;
  79     HPS                             m_hPS;
  80 };
  81
  82 #define M_REGION (((wxRegionRefData*)m_refData)->m_hRegion)
  83 #define M_REGION_OF(rgn) (((wxRegionRefData*)(rgn.m_refData))->m_hRegion)
  84
  85 //-----------------------------------------------------------------------------
  86 // wxRegion
  87 //-----------------------------------------------------------------------------
  88
  89 // General remark:
  90 // wxRegion is always basically stored in wx coordinates. However, since
  91 // OS/2's internal functions rely on "top > bottom", the values of top and
  92 // bottom values of a region need to be interchanged, as compared to wx.
  93 // This needs to be taken into account when feeding any rectangle to wx _or_
  94 // when accessing the region data via GetBox, wxRegionIterator or otherwise.
  95
  96 /*!
  97  * Create an empty region.
  98  */
  99 wxRegion::wxRegion()
 100 {
 101     m_refData = new wxRegionRefData;
 102 } // end of wxRegion::wxRegion
 103
 104 wxRegion::wxRegion(
 105   WXHRGN                            hRegion,
 106   WXHDC                             hPS
 107 )
 108 {
 109     m_refData = new wxRegionRefData;
 110     M_REGION = (HRGN) hRegion;
 111     (((wxRegionRefData*)m_refData)->m_hPS) = hPS;
 112 } // end of wxRegion::wxRegion
 113
 114 wxRegion::wxRegion(
 115   wxCoord                           x
 116 , wxCoord                           y
 117 , wxCoord                           vWidth
 118 , wxCoord                           vHeight
 119 )
 120 {
 121     RECTL                           vRect;
 122     SIZEL                           vSize = {0, 0};
 123     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 124     HDC                             hDC = ::DevOpenDC( vHabmain
 125                                                       ,OD_MEMORY
 126                                                       ,"*"
 127                                                       ,5L
 128                                                       ,(PDEVOPENDATA)&vDop
 129                                                       ,NULLHANDLE
 130                                                      );
 131
 132
 133     vRect.xLeft   = x;
 134     vRect.xRight  = x + vWidth;
 135     vRect.yBottom = y;
 136     vRect.yTop    = y + vHeight;
 137
 138     m_refData     = new wxRegionRefData;
 139
 140     //
 141     // Need a PS to create a Region
 142     //
 143     ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
 144                                                          ,hDC
 145                                                          ,&vSize
 146                                                          ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
 147                                                         );
 148     M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
 149                                       ,1
 150                                       ,&vRect
 151                                      );
 152 } // end of wxRegion::wxRegion
 153
 154 wxRegion::wxRegion(const wxPoint& rTopLeft,
 155                    const wxPoint& rBottomRight)
 156 {
 157     RECTL                           vRect;
 158     SIZEL                           vSize = {0, 0};
 159     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 160     HDC                             hDC = ::DevOpenDC( vHabmain
 161                                                       ,OD_MEMORY
 162                                                       ,"*"
 163                                                       ,5L
 164                                                       ,(PDEVOPENDATA)&vDop
 165                                                       ,NULLHANDLE
 166                                                      );
 167
 168     vRect.xLeft   = rTopLeft.x;
 169     vRect.xRight  = rBottomRight.x;
 170     vRect.yBottom = rTopLeft.y;
 171     vRect.yTop    = rBottomRight.y;
 172
 173     m_refData     = new wxRegionRefData;
 174
 175     //
 176     // Need a PS to create a Region
 177     //
 178     ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
 179                                                          ,hDC
 180                                                          ,&vSize
 181                                                          ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
 182                                                         );
 183     M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
 184                                       ,1
 185                                       ,&vRect
 186                                      );
 187 } // end of wxRegion::wxRegion
 188
 189 wxRegion::wxRegion(const wxRect& rRect)
 190 {
 191     RECTL                           vRect;
 192     SIZEL                           vSize = {0, 0};
 193     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 194     HDC                             hDC = ::DevOpenDC( vHabmain
 195                                                       ,OD_MEMORY
 196                                                       ,"*"
 197                                                       ,5L
 198                                                       ,(PDEVOPENDATA)&vDop
 199                                                       ,NULLHANDLE
 200                                                      );
 201
 202
 203     vRect.xLeft   = rRect.x;
 204     vRect.xRight  = rRect.x + rRect.width;
 205     vRect.yBottom = rRect.y;
 206     vRect.yTop    = rRect.y + rRect.height;
 207
 208     m_refData     = new wxRegionRefData;
 209
 210     //
 211     // Need a PS to create a Region
 212     //
 213     ((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
 214                                                          ,hDC
 215                                                          ,&vSize
 216                                                          ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
 217                                                         );
 218     M_REGION      = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
 219                                       ,1
 220                                       ,&vRect
 221                                      );
 222 } // end of wxRegion::wxRegion
 223
 224 wxRegion::wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode WXUNUSED(fillStyle))
 225 {
 226     // TO DO
 227 }
 228
 229 //
 230 // Destroy the region.
 231 //
 232 wxRegion::~wxRegion()
 233 {
 234 } // end of wxRegion::~wxRegion
 235
 236 wxGDIRefData *wxRegion::CreateGDIRefData() const
 237 {
 238     return new wxRegionRefData;
 239 }
 240
 241 wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
 242 {
 243     return new wxRegionRefData(*(wxRegionRefData *)data);
 244 }
 245
 246 //-----------------------------------------------------------------------------
 247 //# Modify region
 248 //-----------------------------------------------------------------------------
 249
 250 bool wxRegion::DoOffset( wxCoord x, wxCoord y )
 251 {
 252     if ( !x && !y )
 253     {
 254         // nothing to do
 255         return true;
 256     }
 257
 258     AllocExclusive();
 259
 260 #if 0
 261     if ( ::OffsetRgn(GetHrgn(), x, y) == ERROR )
 262     {
 263         wxLogLastError(wxT("OffsetRgn"));
 264
 265         return false;
 266     }
 267 #endif
 268     return true;
 269 }
 270
 271 //
 272 // Clear current region
 273 //
 274 void wxRegion::Clear()
 275 {
 276     UnRef();
 277 } // end of wxRegion::Clear
 278
 279 //
 280 // Union region with this.
 281 //
 282 bool wxRegion::DoCombine( const wxRegion& rRegion, wxRegionOp eOp )
 283 {
 284     //
 285     // We can't use the API functions if we don't have a valid region handle
 286     //
 287     if (!m_refData)
 288     {
 289         // combining with an empty/invalid region works differently depending
 290         // on the operation
 291         switch (eOp)
 292         {
 293             case wxRGN_COPY:
 294             case wxRGN_OR:
 295             case wxRGN_XOR:
 296                 *this = rRegion;
 297                 break;
 298
 299             default:
 300                 wxFAIL_MSG( wxT("unknown region operation") );
 301                 // fall through
 302
 303             case wxRGN_AND:
 304             case wxRGN_DIFF:
 305                 // leave empty/invalid
 306                 return false;
 307         }
 308     }
 309     else // we have a valid region
 310     {
 311
 312         LONG                        lMode = 0;
 313
 314         switch (eOp)
 315         {
 316             case wxRGN_AND:
 317                 lMode = CRGN_AND;
 318                 break;
 319
 320             case wxRGN_OR:
 321                 lMode = CRGN_OR;
 322                 break;
 323
 324             case wxRGN_XOR:
 325                 lMode = CRGN_XOR;
 326                 break;
 327
 328             case wxRGN_DIFF:
 329                 lMode = CRGN_DIFF;
 330                 break;
 331
 332             case wxRGN_COPY:
 333             default:
 334                 lMode = CRGN_COPY;
 335                 break;
 336         }
 337         return (::GpiCombineRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
 338                                    ,M_REGION
 339                                    ,M_REGION
 340                                    ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion
 341                                    ,lMode
 342                                   ) != RGN_ERROR);
 343     }
 344     return true;
 345 } // end of wxRegion::Combine
 346
 347 //-----------------------------------------------------------------------------
 348 //# Information on region
 349 //-----------------------------------------------------------------------------
 350
 351 bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
 352 {
 353     return false;
 354 }
 355
 356 //
 357 // Outer bounds of region
 358 //
 359 bool wxRegion::DoGetBox(
 360   wxCoord&                          x
 361 , wxCoord&                          y
 362 , wxCoord&                          vWidth
 363 , wxCoord&                          vHeight
 364 ) const
 365 {
 366     if (m_refData)
 367     {
 368         RECTL                       vRect;
 369         APIRET                      rc;
 370
 371         rc = ::GpiQueryRegionBox( ((wxRegionRefData*)m_refData)->m_hPS
 372                             ,M_REGION
 373                             ,&vRect
 374                            );
 375         x       = vRect.xLeft;
 376         y       = vRect.yBottom;
 377         vWidth  = vRect.xRight - vRect.xLeft;
 378         vHeight = vRect.yTop - vRect.yBottom;
 379         return true;
 380     }
 381     else
 382     {
 383         x = y = vWidth = vHeight = 0L;
 384         return false;
 385     }
 386 } // end of wxRegion::GetBox
 387
 388 //
 389 // Is region empty?
 390 //
 391 bool wxRegion::IsEmpty() const
 392 {
 393     wxCoord x;
 394     wxCoord y;
 395     wxCoord vWidth;
 396     wxCoord vHeight;
 397
 398     if (M_REGION == 0)
 399         return true;
 400
 401     GetBox( x
 402            ,y
 403            ,vWidth
 404            ,vHeight
 405           );
 406     return ((vWidth == 0) && (vHeight == 0));
 407 } // end of wxRegion::IsEmpty
 408
 409 //-----------------------------------------------------------------------------
 410 // Tests
 411 //-----------------------------------------------------------------------------
 412 //
 413 // Does the region contain the point pt?
 414 //
 415 wxRegionContain wxRegion::DoContainsPoint( wxCoord x, wxCoord y ) const
 416 {
 417     POINTL vPoint = { x, y };
 418
 419     if (!m_refData)
 420         return wxOutRegion;
 421
 422     LONG lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
 423                                     M_REGION,
 424                                     &vPoint
 425                                   );
 426     if (lInside == PRGN_INSIDE)
 427         return wxInRegion;
 428     else
 429         return wxOutRegion;
 430 } // end of wxRegion::Contains
 431
 432 //
 433 // Does the region contain the rectangle (x, y, w, h)?
 434 //
 435 wxRegionContain wxRegion::DoContainsRect(const wxRect& rect) const
 436 {
 437     if (!m_refData)
 438         return wxOutRegion;
 439
 440     RECTL   vRect;
 441     vRect.xLeft   = rect.x;
 442     vRect.xRight  = rect.x + rect.width;
 443     vRect.yTop    = rect.y + rect.height;
 444     vRect.yBottom = rect.y;
 445
 446     LONG lInside = ::GpiRectInRegion( ((wxRegionRefData*)m_refData)->m_hPS,
 447                                       M_REGION,
 448                                       &vRect
 449                                     );
 450     switch (lInside)
 451     {
 452         case RRGN_INSIDE    :   return wxInRegion;
 453         case RRGN_PARTIAL   :   return wxPartRegion;
 454         case RRGN_ERROR     :
 455         default             :   return wxOutRegion;
 456     }
 457
 458 } // end of wxRegion::Contains
 459
 460 //
 461 // Get internal region handle
 462 //
 463 WXHRGN wxRegion::GetHRGN() const
 464 {
 465     if (!m_refData)
 466         return (WXHRGN) 0;
 467     return (WXHRGN) M_REGION;
 468 }
 469
 470 //
 471 // Set a new PS, this means we have to recreate the old region in the new
 472 // PS
 473 //
 474 void wxRegion::SetPS(
 475   HPS                               hPS
 476 )
 477 {
 478     RGNRECT                     vRgnData;
 479     PRECTL                      pRect = NULL;
 480
 481     vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
 482     if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
 483                               ,((wxRegionRefData*)m_refData)->m_hRegion
 484                               ,NULL
 485                               ,&vRgnData
 486                               ,NULL
 487                              ))
 488     {
 489         pRect = new RECTL[vRgnData.crcReturned];
 490         vRgnData.crc = vRgnData.crcReturned;
 491         vRgnData.ircStart = 1;
 492         if (::GpiQueryRegionRects( ((wxRegionRefData*)m_refData)->m_hPS
 493                                   ,((wxRegionRefData*)m_refData)->m_hRegion
 494                                   ,NULL
 495                                   ,&vRgnData
 496                                   ,pRect
 497                                  ))
 498         {
 499             //
 500             // First destroy the region out of the old PS
 501             // and then create it in the new and set the new to current
 502             //
 503             ::GpiDestroyRegion( ((wxRegionRefData*)m_refData)->m_hPS
 504                                ,M_REGION
 505                               );
 506             ((wxRegionRefData*)m_refData)->m_hRegion = ::GpiCreateRegion( hPS
 507                                                                          ,vRgnData.crcReturned
 508                                                                          ,pRect
 509                                                                         );
 510             ((wxRegionRefData*)m_refData)->m_hPS = hPS;
 511         }
 512         delete [] pRect;
 513     }
 514 } // end of wxRegion::SetPS
 515
 516 ///////////////////////////////////////////////////////////////////////////////
 517 //                                                                           //
 518 //                             wxRegionIterator                              //
 519 //                                                                           //
 520 ///////////////////////////////////////////////////////////////////////////////
 521
 522 //
 523 // Initialize empty iterator
 524 //
 525 wxRegionIterator::wxRegionIterator()
 526 : m_lCurrent(0)
 527 , m_lNumRects(0)
 528 , m_pRects(NULL)
 529 {
 530 } // end of wxRegionIterator::wxRegionIterator
 531
 532 wxRegionIterator::~wxRegionIterator()
 533 {
 534     if (m_pRects)
 535         delete[] m_pRects;
 536 } // end of wxRegionIterator::~wxRegionIterator
 537
 538 //
 539 // Initialize iterator for region
 540 //
 541 wxRegionIterator::wxRegionIterator(
 542   const wxRegion&                   rRegion
 543 )
 544 {
 545     m_pRects = NULL;
 546     Reset(rRegion);
 547 } // end of wxRegionIterator::wxRegionIterator
 548
 549 //
 550 // Reset iterator for a new /e region.
 551 //
 552 void wxRegionIterator::Reset(
 553   const wxRegion&                   rRegion
 554 )
 555 {
 556     m_lCurrent = 0;
 557     m_lNumRects = 0;
 558     m_vRegion  = rRegion;
 559
 560     if (m_pRects)
 561         delete[] m_pRects;
 562
 563     m_pRects = NULL;
 564
 565     if (m_vRegion.Empty())
 566         m_lNumRects = 0;
 567     else
 568     {
 569         RGNRECT                     vRgnData;
 570         PRECTL                      pRect;
 571
 572         vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
 573         if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS     // Pres space
 574                                   ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of region to query
 575                                   ,NULL                                             // Return all RECTs
 576                                   ,&vRgnData                                        // Will contain number or RECTs in region
 577                                   ,NULL                                             // NULL to return number of RECTs
 578                                  ))
 579         {
 580             pRect = new RECTL[vRgnData.crcReturned];
 581             m_pRects = new wxRect[vRgnData.crcReturned];
 582             vRgnData.crc = vRgnData.crcReturned;
 583             m_lNumRects = vRgnData.crcReturned;
 584             vRgnData.ircStart = 1;
 585             if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS     // Pres space of source
 586                                       ,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of source region
 587                                       ,NULL                                             // Return all RECTs
 588                                       ,&vRgnData                                        // Operations set to return rects
 589                                       ,pRect                                            // Will contain the actual RECTS
 590                                      ))
 591             {
 592 #if 0
 593                 M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
 594                                              ,vRgnData.crcReturned
 595                                              ,pRect
 596                                             );
 597 #endif
 598                 for( LONG i = 0; i < m_lNumRects; i++)
 599                 {
 600                     m_pRects[i].x      = pRect[i].xLeft;
 601                     m_pRects[i].width  = pRect[i].xRight - pRect[i].xLeft;
 602                     m_pRects[i].y      = pRect[i].yBottom;
 603                     m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
 604                 }
 605 #if 0
 606                 ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;
 607 #endif
 608             }
 609         }
 610     }
 611 } // end of wxRegionIterator::Reset
 612
 613 //
 614 // Increment iterator. The rectangle returned is the one after the
 615 // incrementation.
 616 //
 617 void wxRegionIterator::operator++ ()
 618 {
 619     if (m_lCurrent < m_lNumRects)
 620         ++m_lCurrent;
 621 } // end of wxRegionIterator::operator ++
 622
 623 //
 624 // Increment iterator. The rectangle returned is the one before the
 625 // incrementation.
 626 //
 627 void wxRegionIterator::operator++ (int)
 628 {
 629     if (m_lCurrent < m_lNumRects)
 630         ++m_lCurrent;
 631 } // end of wxRegionIterator::operator++
 632
 633 wxCoord wxRegionIterator::GetX() const
 634 {
 635     if (m_lCurrent < m_lNumRects)
 636         return m_pRects[m_lCurrent].x;
 637     return 0L;
 638 } // end of wxRegionIterator::GetX
 639
 640 wxCoord wxRegionIterator::GetY() const
 641 {
 642     if (m_lCurrent < m_lNumRects)
 643         return m_pRects[m_lCurrent].y;
 644     return 0L;
 645 } // end of wxRegionIterator::GetY
 646
 647 wxCoord wxRegionIterator::GetW() const
 648 {
 649     if (m_lCurrent < m_lNumRects)
 650         return m_pRects[m_lCurrent].width ;
 651     return 0L;
 652 } // end of wxRegionIterator::GetW
 653
 654 wxCoord wxRegionIterator::GetH() const
 655 {
 656     if (m_lCurrent < m_lNumRects)
 657         return m_pRects[m_lCurrent].height;
 658     return 0L;
 659 } // end of wxRegionIterator::GetH