src/msw/region.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:      src/msw/region.cpp
   3 // Purpose:   wxRegion implementation using Win32 API
   4 // Author:    Vadim Zeitlin
   5 // Modified by:
   6 // Created:   Fri Oct 24 10:46:34 MET 1997
   7 // RCS-ID:    $Id$
   8 // Copyright: (c) 1997-2002 wxWidgets team
   9 // Licence:   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 #include "wx/region.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/gdicmn.h"
  31 #endif
  32
  33 #include "wx/msw/private.h"
  34
  35 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
  36 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
  37
  38 // ----------------------------------------------------------------------------
  39 // wxRegionRefData implementation
  40 // ----------------------------------------------------------------------------
  41
  42 class WXDLLEXPORT wxRegionRefData : public wxGDIRefData
  43 {
  44 public:
  45     wxRegionRefData()
  46     {
  47         m_region = 0;
  48     }
  49
  50     wxRegionRefData(const wxRegionRefData& data) : wxGDIRefData()
  51     {
  52 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  53         DWORD noBytes = ::GetRegionData(data.m_region, 0, NULL);
  54         RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
  55         ::GetRegionData(data.m_region, noBytes, rgnData);
  56         m_region = ::ExtCreateRegion(NULL, noBytes, rgnData);
  57         delete[] (char*) rgnData;
  58 #else
  59         RECT rect;
  60         ::GetRgnBox(data.m_region, &rect);
  61         m_region = ::CreateRectRgnIndirect(&rect);
  62 #endif
  63     }
  64
  65     virtual ~wxRegionRefData()
  66     {
  67         ::DeleteObject(m_region);
  68         m_region = 0;
  69     }
  70
  71     HRGN m_region;
  72
  73 private:
  74 // Cannot use
  75 //  DECLARE_NO_COPY_CLASS(wxRegionRefData)
  76 // because copy constructor is explicitly declared above;
  77 // but no copy assignment operator is defined, so declare
  78 // it private to prevent the compiler from defining it:
  79     wxRegionRefData& operator=(const wxRegionRefData&);
  80 };
  81
  82 #define M_REGION (((wxRegionRefData*)m_refData)->m_region)
  83 #define M_REGION_OF(rgn) (((wxRegionRefData*)(rgn.m_refData))->m_region)
  84
  85 // ============================================================================
  86 // wxRegion implementation
  87 // ============================================================================
  88
  89 // ----------------------------------------------------------------------------
  90 // ctors and dtor
  91 // ----------------------------------------------------------------------------
  92
  93 wxRegion::wxRegion()
  94 {
  95     m_refData = (wxRegionRefData *)NULL;
  96 }
  97
  98 wxRegion::wxRegion(WXHRGN hRegion)
  99 {
 100     m_refData = new wxRegionRefData;
 101     M_REGION = (HRGN) hRegion;
 102 }
 103
 104 wxRegion::wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 105 {
 106     m_refData = new wxRegionRefData;
 107     M_REGION = ::CreateRectRgn(x, y, x + w, y + h);
 108 }
 109
 110 wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
 111 {
 112     m_refData = new wxRegionRefData;
 113     M_REGION = ::CreateRectRgn(topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
 114 }
 115
 116 wxRegion::wxRegion(const wxRect& rect)
 117 {
 118     m_refData = new wxRegionRefData;
 119     M_REGION = ::CreateRectRgn(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
 120 }
 121
 122 wxRegion::wxRegion(size_t n, const wxPoint *points, int fillStyle)
 123 {
 124 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
 125     wxUnusedVar(n);
 126     wxUnusedVar(points);
 127     wxUnusedVar(fillStyle);
 128     m_refData = NULL;
 129     M_REGION = NULL;
 130 #else
 131     m_refData = new wxRegionRefData;
 132     M_REGION = ::CreatePolygonRgn
 133                (
 134                     (POINT*)points,
 135                     n,
 136                     fillStyle == wxODDEVEN_RULE ? ALTERNATE : WINDING
 137                );
 138 #endif
 139 }
 140
 141 wxRegion::~wxRegion()
 142 {
 143     // m_refData unrefed in ~wxObject
 144 }
 145
 146 wxObjectRefData *wxRegion::CreateRefData() const
 147 {
 148     return new wxRegionRefData;
 149 }
 150
 151 wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
 152 {
 153     return new wxRegionRefData(*(wxRegionRefData *)data);
 154 }
 155
 156 // ----------------------------------------------------------------------------
 157 // wxRegion operations
 158 // ----------------------------------------------------------------------------
 159
 160 // Clear current region
 161 void wxRegion::Clear()
 162 {
 163     UnRef();
 164 }
 165
 166 bool wxRegion::Offset(wxCoord x, wxCoord y)
 167 {
 168     wxCHECK_MSG( M_REGION, false, _T("invalid wxRegion") );
 169
 170     if ( !x && !y )
 171     {
 172         // nothing to do
 173         return true;
 174     }
 175
 176     AllocExclusive();
 177
 178     if ( ::OffsetRgn(GetHrgn(), x, y) == ERROR )
 179     {
 180         wxLogLastError(_T("OffsetRgn"));
 181
 182         return false;
 183     }
 184
 185     return true;
 186 }
 187
 188 // combine another region with this one
 189 bool wxRegion::Combine(const wxRegion& rgn, wxRegionOp op)
 190 {
 191     // we can't use the API functions if we don't have a valid region handle
 192     if ( !m_refData )
 193     {
 194         // combining with an empty/invalid region works differently depending
 195         // on the operation
 196         switch ( op )
 197         {
 198             case wxRGN_COPY:
 199             case wxRGN_OR:
 200             case wxRGN_XOR:
 201                 *this = rgn;
 202                 break;
 203
 204             default:
 205                 wxFAIL_MSG( _T("unknown region operation") );
 206                 // fall through
 207
 208             case wxRGN_AND:
 209             case wxRGN_DIFF:
 210                 // leave empty/invalid
 211                 return false;
 212         }
 213     }
 214     else // we have a valid region
 215     {
 216         AllocExclusive();
 217
 218         int mode;
 219         switch ( op )
 220         {
 221             case wxRGN_AND:
 222                 mode = RGN_AND;
 223                 break;
 224
 225             case wxRGN_OR:
 226                 mode = RGN_OR;
 227                 break;
 228
 229             case wxRGN_XOR:
 230                 mode = RGN_XOR;
 231                 break;
 232
 233             case wxRGN_DIFF:
 234                 mode = RGN_DIFF;
 235                 break;
 236
 237             default:
 238                 wxFAIL_MSG( _T("unknown region operation") );
 239                 // fall through
 240
 241             case wxRGN_COPY:
 242                 mode = RGN_COPY;
 243                 break;
 244         }
 245
 246         if ( ::CombineRgn(M_REGION, M_REGION, M_REGION_OF(rgn), mode) == ERROR )
 247         {
 248             wxLogLastError(_T("CombineRgn"));
 249
 250             return false;
 251         }
 252     }
 253
 254     return true;
 255 }
 256
 257 // Combine rectangle (x, y, w, h) with this.
 258 bool wxRegion::Combine(wxCoord x, wxCoord y,
 259                        wxCoord width, wxCoord height,
 260                        wxRegionOp op)
 261 {
 262     return Combine(wxRegion(x, y, width, height), op);
 263 }
 264
 265 bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
 266 {
 267     return Combine(rect.GetLeft(), rect.GetTop(),
 268                    rect.GetWidth(), rect.GetHeight(), op);
 269 }
 270
 271 // ----------------------------------------------------------------------------
 272 // wxRegion bounding box
 273 // ----------------------------------------------------------------------------
 274
 275 // Outer bounds of region
 276 void wxRegion::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const
 277 {
 278     if (m_refData)
 279     {
 280         RECT rect;
 281         ::GetRgnBox(M_REGION, & rect);
 282         x = rect.left;
 283         y = rect.top;
 284         w = rect.right - rect.left;
 285         h = rect.bottom - rect.top;
 286     }
 287     else
 288     {
 289         x = y = w = h = 0;
 290     }
 291 }
 292
 293 wxRect wxRegion::GetBox() const
 294 {
 295     wxCoord x, y, w, h;
 296     GetBox(x, y, w, h);
 297     return wxRect(x, y, w, h);
 298 }
 299
 300 // Is region empty?
 301 bool wxRegion::Empty() const
 302 {
 303     wxCoord x, y, w, h;
 304     GetBox(x, y, w, h);
 305
 306     return (w == 0) && (h == 0);
 307 }
 308
 309 // ----------------------------------------------------------------------------
 310 // wxRegion hit testing
 311 // ----------------------------------------------------------------------------
 312
 313 // Does the region contain the point (x,y)?
 314 wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y) const
 315 {
 316     if (!m_refData)
 317         return wxOutRegion;
 318
 319     return ::PtInRegion(M_REGION, (int) x, (int) y) ? wxInRegion : wxOutRegion;
 320 }
 321
 322 // Does the region contain the point pt?
 323 wxRegionContain wxRegion::Contains(const wxPoint& pt) const
 324 {
 325     return Contains(pt.x, pt.y);
 326 }
 327
 328 // Does the region contain the rectangle (x, y, w, h)?
 329 wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y,
 330                                    wxCoord w, wxCoord h) const
 331 {
 332     if (!m_refData)
 333         return wxOutRegion;
 334
 335     RECT rect;
 336     rect.left = x;
 337     rect.top = y;
 338     rect.right = x + w;
 339     rect.bottom = y + h;
 340
 341     return ::RectInRegion(M_REGION, &rect) ? wxInRegion : wxOutRegion;
 342 }
 343
 344 // Does the region contain the rectangle rect
 345 wxRegionContain wxRegion::Contains(const wxRect& rect) const
 346 {
 347     return Contains(rect.x, rect.y, rect.width, rect.height);
 348 }
 349
 350 // Get internal region handle
 351 WXHRGN wxRegion::GetHRGN() const
 352 {
 353     return (WXHRGN)(m_refData ? M_REGION : 0);
 354 }
 355
 356 // ============================================================================
 357 // wxRegionIterator implementation
 358 // ============================================================================
 359
 360 // ----------------------------------------------------------------------------
 361 // wxRegionIterator ctors/dtor
 362 // ----------------------------------------------------------------------------
 363
 364 void wxRegionIterator::Init()
 365 {
 366     m_current =
 367     m_numRects = 0;
 368
 369     m_rects = NULL;
 370 }
 371
 372 wxRegionIterator::~wxRegionIterator()
 373 {
 374     delete [] m_rects;
 375 }
 376
 377 // Initialize iterator for region
 378 wxRegionIterator::wxRegionIterator(const wxRegion& region)
 379 {
 380     m_rects = NULL;
 381
 382     Reset(region);
 383 }
 384
 385 wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& ri)
 386 {
 387     delete [] m_rects;
 388
 389     m_current = ri.m_current;
 390     m_numRects = ri.m_numRects;
 391     if ( m_numRects )
 392     {
 393         m_rects = new wxRect[m_numRects];
 394         for ( long n = 0; n < m_numRects; n++ )
 395             m_rects[n] = ri.m_rects[n];
 396     }
 397     else
 398     {
 399         m_rects = NULL;
 400     }
 401
 402     return *this;
 403 }
 404
 405 // ----------------------------------------------------------------------------
 406 // wxRegionIterator operations
 407 // ----------------------------------------------------------------------------
 408
 409 // Reset iterator for a new region.
 410 void wxRegionIterator::Reset(const wxRegion& region)
 411 {
 412     m_current = 0;
 413     m_region = region;
 414
 415     if (m_rects)
 416     {
 417         delete[] m_rects;
 418
 419         m_rects = NULL;
 420     }
 421
 422     if (m_region.Empty())
 423         m_numRects = 0;
 424     else
 425     {
 426         DWORD noBytes = ::GetRegionData(((wxRegionRefData*)region.m_refData)->m_region, 0, NULL);
 427         RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
 428         ::GetRegionData(((wxRegionRefData*)region.m_refData)->m_region, noBytes, rgnData);
 429
 430         RGNDATAHEADER* header = (RGNDATAHEADER*) rgnData;
 431
 432         m_rects = new wxRect[header->nCount];
 433
 434         RECT* rect = (RECT*) ((char*)rgnData + sizeof(RGNDATAHEADER));
 435         size_t i;
 436         for (i = 0; i < header->nCount; i++)
 437         {
 438             m_rects[i] = wxRect(rect->left, rect->top,
 439                                  rect->right - rect->left, rect->bottom - rect->top);
 440             rect ++; // Advances pointer by sizeof(RECT)
 441         }
 442
 443         m_numRects = header->nCount;
 444
 445         delete[] (char*) rgnData;
 446     }
 447 }
 448
 449 wxRegionIterator& wxRegionIterator::operator++()
 450 {
 451     if (m_current < m_numRects)
 452         ++m_current;
 453
 454     return *this;
 455 }
 456
 457 wxRegionIterator wxRegionIterator::operator ++ (int)
 458 {
 459     wxRegionIterator tmp = *this;
 460     if (m_current < m_numRects)
 461         ++m_current;
 462
 463     return tmp;
 464 }
 465
 466 // ----------------------------------------------------------------------------
 467 // wxRegionIterator accessors
 468 // ----------------------------------------------------------------------------
 469
 470 wxCoord wxRegionIterator::GetX() const
 471 {
 472     wxCHECK_MSG( m_current < m_numRects, 0, _T("invalid wxRegionIterator") );
 473
 474     return m_rects[m_current].x;
 475 }
 476
 477 wxCoord wxRegionIterator::GetY() const
 478 {
 479     wxCHECK_MSG( m_current < m_numRects, 0, _T("invalid wxRegionIterator") );
 480
 481     return m_rects[m_current].y;
 482 }
 483
 484 wxCoord wxRegionIterator::GetW() const
 485 {
 486     wxCHECK_MSG( m_current < m_numRects, 0, _T("invalid wxRegionIterator") );
 487
 488     return m_rects[m_current].width;
 489 }
 490
 491 wxCoord wxRegionIterator::GetH() const
 492 {
 493     wxCHECK_MSG( m_current < m_numRects, 0, _T("invalid wxRegionIterator") );
 494
 495     return m_rects[m_current].height;
 496 }