src/osx/carbon/region.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // File:      src/mac/carbon/region.cpp
   3 // Purpose:   Region class
   4 // Author:    Stefan Csomor
   5 // Created:   Fri Oct 24 10:46:34 MET 1997
   6 // RCS-ID:    $Id$
   7 // Copyright: (c) 1997 Stefan Csomor
   8 // Licence:   wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 #include "wx/wxprec.h"
  12
  13 #include "wx/region.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/gdicmn.h"
  17 #endif
  18
  19 #include "wx/osx/uma.h"
  20
  21 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
  22 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
  23
  24 //-----------------------------------------------------------------------------
  25 // wxRegionRefData implementation
  26 //-----------------------------------------------------------------------------
  27
  28 class WXDLLEXPORT wxRegionRefData : public wxGDIRefData
  29 {
  30 public:
  31     wxRegionRefData()
  32     {
  33         m_macRgn.reset( HIShapeCreateMutable() );
  34     }
  35
  36     wxRegionRefData(wxCFRef<HIShapeRef> &region)
  37     {
  38         m_macRgn.reset( HIShapeCreateMutableCopy(region) );
  39     }
  40
  41     wxRegionRefData(long x, long y, long w, long h)
  42     {
  43         CGRect r = CGRectMake(x,y,w,h);
  44         wxCFRef<HIShapeRef> rect(HIShapeCreateWithRect(&r));
  45         m_macRgn.reset( HIShapeCreateMutableCopy(rect) );
  46     }
  47
  48     wxRegionRefData(const wxRegionRefData& data)
  49         : wxGDIRefData()
  50     {
  51         m_macRgn.reset( HIShapeCreateMutableCopy(data.m_macRgn) );
  52     }
  53
  54     virtual ~wxRegionRefData()
  55     {
  56     }
  57
  58     wxCFRef<HIMutableShapeRef> m_macRgn;
  59 };
  60
  61 #define M_REGION (((wxRegionRefData*)m_refData)->m_macRgn)
  62 #define OTHER_M_REGION(a) (((wxRegionRefData*)(a.m_refData))->m_macRgn)
  63
  64 //-----------------------------------------------------------------------------
  65 // wxRegion
  66 //-----------------------------------------------------------------------------
  67
  68 /*!
  69  * Create an empty region.
  70  */
  71 wxRegion::wxRegion()
  72 {
  73     m_refData = new wxRegionRefData();
  74 }
  75
  76 wxRegion::wxRegion(WXHRGN hRegion )
  77 {
  78     wxCFRef< HIShapeRef > shape( (HIShapeRef) hRegion );
  79     m_refData = new wxRegionRefData(shape);
  80 }
  81
  82 wxRegion::wxRegion(long x, long y, long w, long h)
  83 {
  84     m_refData = new wxRegionRefData(x , y , w , h );
  85 }
  86
  87 wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
  88 {
  89     m_refData = new wxRegionRefData(topLeft.x , topLeft.y ,
  90                                     topLeft.x - bottomRight.x ,
  91                                     topLeft.y - bottomRight.y);
  92 }
  93
  94 wxRegion::wxRegion(const wxRect& rect)
  95 {
  96     m_refData = new wxRegionRefData(rect.x , rect.y , rect.width , rect.height);
  97 }
  98
  99 wxRegion::wxRegion(size_t n, const wxPoint *points, int WXUNUSED(fillStyle))
 100 {
 101     wxUnusedVar(n);
 102     wxUnusedVar(points);
 103
 104 #ifndef __LP64__
 105
 106     // TODO : any APIs ?
 107     // OS X somehow does not collect the region invisibly as before, so sometimes things
 108     // get drawn on screen instead of just being combined into a region, therefore we allocate a temp gworld now
 109
 110     GWorldPtr gWorld = NULL;
 111     GWorldPtr oldWorld;
 112     GDHandle oldGDHandle;
 113     OSStatus err;
 114     Rect destRect = { 0, 0, 1, 1 };
 115
 116     ::GetGWorld( &oldWorld, &oldGDHandle );
 117     err = ::NewGWorld( &gWorld, 32, &destRect, NULL, NULL, 0 );
 118     if ( err == noErr )
 119     {
 120         ::SetGWorld( gWorld, GetGDevice() );
 121
 122         OpenRgn();
 123
 124         wxCoord x1, x2 , y1 , y2 ;
 125         x2 = x1 = points[0].x ;
 126         y2 = y1 = points[0].y ;
 127
 128         ::MoveTo( x1, y1 );
 129         for (size_t i = 1; i < n; i++)
 130         {
 131             x2 = points[i].x ;
 132             y2 = points[i].y ;
 133             ::LineTo( x2, y2 );
 134         }
 135
 136         // close the polyline if necessary
 137         if ( x1 != x2 || y1 != y2 )
 138             ::LineTo( x1, y1 ) ;
 139
 140         RgnHandle tempRgn = NewRgn();
 141         CloseRgn( tempRgn ) ;
 142
 143         ::SetGWorld( oldWorld, oldGDHandle );
 144         wxCFRef<HIShapeRef> tempShape( HIShapeCreateWithQDRgn(tempRgn ) );
 145         m_refData = new wxRegionRefData(tempShape);
 146         DisposeRgn( tempRgn );
 147     }
 148     else
 149     {
 150         m_refData = new wxRegionRefData;
 151     }
 152 #else
 153     wxFAIL_MSG( "not implemented" );
 154     m_refData = NULL;
 155 #endif
 156 }
 157
 158 wxRegion::~wxRegion()
 159 {
 160     // m_refData unrefed in ~wxObject
 161 }
 162
 163 wxGDIRefData *wxRegion::CreateGDIRefData() const
 164 {
 165     return new wxRegionRefData;
 166 }
 167
 168 wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
 169 {
 170     return new wxRegionRefData(*static_cast<const wxRegionRefData *>(data));
 171 }
 172
 173 //-----------------------------------------------------------------------------
 174 //# Modify region
 175 //-----------------------------------------------------------------------------
 176
 177 //! Clear current region
 178 void wxRegion::Clear()
 179 {
 180     UnRef();
 181 }
 182
 183 // Move the region
 184 bool wxRegion::DoOffset(wxCoord x, wxCoord y)
 185 {
 186     wxCHECK_MSG( M_REGION, false, _T("invalid wxRegion") );
 187
 188     if ( !x && !y )
 189         // nothing to do
 190         return true;
 191
 192     verify_noerr( HIShapeOffset( M_REGION , x , y ) ) ;
 193
 194     return true ;
 195 }
 196
 197
 198 //! Union /e region with this.
 199 bool wxRegion::DoCombine(const wxRegion& region, wxRegionOp op)
 200 {
 201     wxCHECK_MSG( region.Ok(), false, _T("invalid wxRegion") );
 202
 203     // Don't change shared data
 204     if (!m_refData)
 205     {
 206         m_refData = new wxRegionRefData();
 207     }
 208     else if (m_refData->GetRefCount() > 1)
 209     {
 210         wxRegionRefData* ref = (wxRegionRefData*)m_refData;
 211         UnRef();
 212         m_refData = new wxRegionRefData(*ref);
 213     }
 214
 215     switch (op)
 216     {
 217         case wxRGN_AND:
 218             verify_noerr( HIShapeIntersect( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
 219             break ;
 220
 221         case wxRGN_OR:
 222             verify_noerr( HIShapeUnion( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
 223             break ;
 224
 225         case wxRGN_XOR:
 226             {
 227                 // XOR is defined as the difference between union and intersection
 228                 wxCFRef< HIShapeRef > unionshape( HIShapeCreateUnion( M_REGION , OTHER_M_REGION(region) ) );
 229                 wxCFRef< HIShapeRef > intersectionshape( HIShapeCreateIntersection( M_REGION , OTHER_M_REGION(region) ) );
 230                 verify_noerr( HIShapeDifference( unionshape, intersectionshape, M_REGION ) );
 231             }
 232             break ;
 233
 234         case wxRGN_DIFF:
 235             verify_noerr( HIShapeDifference( M_REGION , OTHER_M_REGION(region) , M_REGION ) ) ;
 236             break ;
 237
 238         case wxRGN_COPY:
 239         default:
 240             M_REGION.reset( HIShapeCreateMutableCopy( OTHER_M_REGION(region) ) );
 241             break ;
 242     }
 243
 244     return true;
 245 }
 246
 247 //-----------------------------------------------------------------------------
 248 //# Information on region
 249 //-----------------------------------------------------------------------------
 250
 251 bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
 252 {
 253     wxFAIL_MSG( _T("not implemented") );
 254
 255     return false;
 256 }
 257
 258 // Outer bounds of region
 259 bool wxRegion::DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
 260 {
 261     if (m_refData)
 262     {
 263         CGRect box ;
 264         HIShapeGetBounds( M_REGION , &box ) ;
 265         x = static_cast<int>(box.origin.x);
 266         y = static_cast<int>(box.origin.y);
 267         w = static_cast<int>(box.size.width);
 268         h = static_cast<int>(box.size.height);
 269
 270         return true;
 271     }
 272     else
 273     {
 274         x = y = w = h = 0;
 275
 276         return false;
 277     }
 278 }
 279
 280 // Is region empty?
 281 bool wxRegion::IsEmpty() const
 282 {
 283     if ( m_refData )
 284         return HIShapeIsEmpty( M_REGION ) ;
 285     else
 286         return true ;
 287 }
 288
 289 const WXHRGN wxRegion::GetWXHRGN() const
 290 {
 291     return M_REGION ;
 292 }
 293
 294 //-----------------------------------------------------------------------------
 295 //# Tests
 296 //-----------------------------------------------------------------------------
 297
 298 // Does the region contain the point?
 299 wxRegionContain wxRegion::DoContainsPoint(wxCoord x, wxCoord y) const
 300 {
 301     if (!m_refData)
 302         return wxOutRegion;
 303
 304     CGPoint p = { y , x } ;
 305     if (HIShapeContainsPoint( M_REGION , &p ) )
 306         return wxInRegion;
 307
 308     return wxOutRegion;
 309 }
 310
 311 // Does the region contain the rectangle (x, y, w, h)?
 312 wxRegionContain wxRegion::DoContainsRect(const wxRect& r) const
 313 {
 314     if (!m_refData)
 315         return wxOutRegion;
 316
 317     CGRect rect = CGRectMake(r.x,r.y,r.width,r.height);
 318     wxCFRef<HIShapeRef> rectshape(HIShapeCreateWithRect(&rect));
 319     wxCFRef<HIShapeRef> intersect(HIShapeCreateIntersection(rectshape,M_REGION));
 320     CGRect bounds;
 321     HIShapeGetBounds(intersect, &bounds);
 322
 323     if ( HIShapeIsRectangular(intersect) && CGRectEqualToRect(rect,bounds) )
 324         return wxInRegion;
 325     else if ( HIShapeIsEmpty( intersect ) )
 326         return wxOutRegion;
 327     else
 328         return wxPartRegion;
 329 }
 330
 331 ///////////////////////////////////////////////////////////////////////////////
 332 //                                                                           //
 333 //                               wxRegionIterator                            //
 334 //                                                                           //
 335 ///////////////////////////////////////////////////////////////////////////////
 336
 337 /*!
 338  * Initialize empty iterator
 339  */
 340 wxRegionIterator::wxRegionIterator()
 341     : m_current(0), m_numRects(0), m_rects(NULL)
 342 {
 343 }
 344
 345 wxRegionIterator::~wxRegionIterator()
 346 {
 347     if (m_rects)
 348     {
 349         delete [] m_rects;
 350         m_rects = NULL;
 351     }
 352 }
 353
 354 wxRegionIterator::wxRegionIterator(const wxRegionIterator& iterator)
 355     : wxObject()
 356     , m_current(iterator.m_current)
 357     , m_numRects(0)
 358     , m_rects(NULL)
 359 {
 360     SetRects(iterator.m_numRects, iterator.m_rects);
 361 }
 362
 363 wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& iterator)
 364 {
 365     m_current  = iterator.m_current;
 366     SetRects(iterator.m_numRects, iterator.m_rects);
 367
 368     return *this;
 369 }
 370
 371 /*!
 372  * Set iterator rects for region
 373  */
 374 void wxRegionIterator::SetRects(long numRects, wxRect *rects)
 375 {
 376     if (m_rects)
 377     {
 378         delete [] m_rects;
 379         m_rects = NULL;
 380     }
 381
 382     if (rects && (numRects > 0))
 383     {
 384         int i;
 385
 386         m_rects = new wxRect[numRects];
 387         for (i = 0; i < numRects; i++)
 388             m_rects[i] = rects[i];
 389     }
 390
 391     m_numRects = numRects;
 392 }
 393
 394 /*!
 395  * Initialize iterator for region
 396  */
 397 wxRegionIterator::wxRegionIterator(const wxRegion& region)
 398 {
 399     m_rects = NULL;
 400
 401     Reset(region);
 402 }
 403
 404 /*!
 405  * Reset iterator for a new /e region.
 406  */
 407
 408 #ifndef __LP64__
 409 OSStatus wxMacRegionToRectsCounterCallback(
 410     UInt16 message, RgnHandle WXUNUSED(region), const Rect *WXUNUSED(rect), void *data )
 411 {
 412     long *m_numRects = (long*) data ;
 413     if ( message == kQDRegionToRectsMsgInit )
 414     {
 415         (*m_numRects) = 0 ;
 416     }
 417     else if (message == kQDRegionToRectsMsgParse)
 418     {
 419         (*m_numRects) += 1 ;
 420     }
 421
 422     return noErr;
 423 }
 424
 425 class RegionToRectsCallbackData
 426 {
 427 public :
 428     wxRect* m_rects ;
 429     long m_current ;
 430 };
 431
 432 OSStatus wxMacRegionToRectsSetterCallback(
 433     UInt16 message, RgnHandle WXUNUSED(region), const Rect *rect, void *data )
 434 {
 435     if (message == kQDRegionToRectsMsgParse)
 436     {
 437         RegionToRectsCallbackData *cb = (RegionToRectsCallbackData*) data ;
 438         cb->m_rects[cb->m_current++] = wxRect( rect->left , rect->top , rect->right - rect->left , rect->bottom - rect->top ) ;
 439     }
 440
 441     return noErr;
 442 }
 443 #endif
 444
 445 void wxRegionIterator::Reset(const wxRegion& region)
 446 {
 447     m_current = 0;
 448     m_region = region;
 449
 450     if (m_rects)
 451     {
 452         delete [] m_rects;
 453         m_rects = NULL;
 454     }
 455
 456     if (m_region.IsEmpty())
 457     {
 458         m_numRects = 0;
 459     }
 460     else
 461     {
 462 #ifdef __LP64__
 463         // copying this to a path and dissecting the path would be an option
 464         m_numRects = 1;
 465         m_rects = new wxRect[m_numRects];
 466         m_rects[0] = m_region.GetBox();
 467
 468 #else
 469         RegionToRectsUPP proc = (RegionToRectsUPP) wxMacRegionToRectsCounterCallback;
 470
 471         OSStatus err = noErr;
 472         RgnHandle rgn = NewRgn();
 473         HIShapeGetAsQDRgn(OTHER_M_REGION(region), rgn);
 474
 475         err = QDRegionToRects (rgn, kQDParseRegionFromTopLeft, proc, (void*)&m_numRects);
 476         if (err == noErr)
 477         {
 478             proc = (RegionToRectsUPP) wxMacRegionToRectsSetterCallback;
 479             m_rects = new wxRect[m_numRects];
 480             RegionToRectsCallbackData data ;
 481             data.m_rects = m_rects ;
 482             data.m_current = 0 ;
 483             QDRegionToRects( rgn , kQDParseRegionFromTopLeft, proc, (void*)&data );
 484         }
 485         else
 486         {
 487             m_numRects = 0;
 488         }
 489         DisposeRgn( rgn );
 490 #endif
 491     }
 492 }
 493
 494 /*!
 495  * Increment iterator. The rectangle returned is the one after the
 496  * incrementation.
 497  */
 498 wxRegionIterator& wxRegionIterator::operator ++ ()
 499 {
 500     if (m_current < m_numRects)
 501         ++m_current;
 502
 503     return *this;
 504 }
 505
 506 /*!
 507  * Increment iterator. The rectangle returned is the one before the
 508  * incrementation.
 509  */
 510 wxRegionIterator wxRegionIterator::operator ++ (int)
 511 {
 512     wxRegionIterator previous(*this);
 513
 514     if (m_current < m_numRects)
 515         ++m_current;
 516
 517     return previous;
 518 }
 519
 520 long wxRegionIterator::GetX() const
 521 {
 522     if (m_current < m_numRects)
 523         return m_rects[m_current].x;
 524
 525     return 0;
 526 }
 527
 528 long wxRegionIterator::GetY() const
 529 {
 530     if (m_current < m_numRects)
 531         return m_rects[m_current].y;
 532
 533     return 0;
 534 }
 535
 536 long wxRegionIterator::GetW() const
 537 {
 538     if (m_current < m_numRects)
 539         return m_rects[m_current].width ;
 540
 541     return 0;
 542 }
 543
 544 long wxRegionIterator::GetH() const
 545 {
 546     if (m_current < m_numRects)
 547         return m_rects[m_current].height;
 548
 549     return 0;
 550 }