src/gtk/region.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gtk/region.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Modified:    VZ at 05.10.00: use AllocExclusive(), comparison fixed
   6 // Id:          $Id$
   7 // Copyright:   (c) 1998 Robert Roebling
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #include "wx/region.h"
  23 #include "wx/log.h"
  24 #include "wx/gtk/private.h"
  25
  26 #ifndef __WXGTK20__
  27
  28 // ----------------------------------------------------------------------------
  29 // wxGdkRegion: creates a new region in ctor and destroys in dtor
  30 // ----------------------------------------------------------------------------
  31
  32 class wxGdkRegion
  33 {
  34 public:
  35     wxGdkRegion() { m_region = gdk_region_new(); }
  36     ~wxGdkRegion() { gdk_region_destroy(m_region); }
  37
  38     operator GdkRegion *() const { return m_region; }
  39
  40 private:
  41     GdkRegion *m_region;
  42 };
  43
  44 #endif // __WXGTK20__
  45
  46 // ----------------------------------------------------------------------------
  47 // wxRegionRefData: private class containing the information about the region
  48 // ----------------------------------------------------------------------------
  49
  50 class wxRegionRefData : public wxObjectRefData
  51 {
  52 public:
  53     wxRegionRefData()
  54     {
  55         m_region = NULL;
  56     }
  57
  58     wxRegionRefData(const wxRegionRefData& refData)
  59         : wxObjectRefData()
  60     {
  61 #ifdef __WXGTK20__
  62         m_region = gdk_region_copy(refData.m_region);
  63 #else
  64         m_region = gdk_regions_union(wxGdkRegion(), refData.m_region);
  65 #endif
  66     }
  67
  68     ~wxRegionRefData()
  69     {
  70         if (m_region)
  71             gdk_region_destroy( m_region );
  72     }
  73
  74     GdkRegion  *m_region;
  75 };
  76
  77 // ----------------------------------------------------------------------------
  78 // macros
  79 // ----------------------------------------------------------------------------
  80
  81 #define M_REGIONDATA ((wxRegionRefData *)m_refData)
  82 #define M_REGIONDATA_OF(rgn) ((wxRegionRefData *)(rgn.m_refData))
  83
  84 IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
  85 IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator,wxObject)
  86
  87 // ----------------------------------------------------------------------------
  88 // wxRegion construction
  89 // ----------------------------------------------------------------------------
  90
  91 #define M_REGIONDATA ((wxRegionRefData *)m_refData)
  92
  93 void wxRegion::InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
  94 {
  95     GdkRectangle rect;
  96     rect.x = x;
  97     rect.y = y;
  98     rect.width = w;
  99     rect.height = h;
 100
 101     m_refData = new wxRegionRefData();
 102
 103 #ifdef __WXGTK20__
 104     M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
 105 #else
 106     M_REGIONDATA->m_region = gdk_region_union_with_rect( wxGdkRegion(), &rect );
 107 #endif
 108 }
 109
 110 wxRegion::wxRegion( GdkRegion *region )
 111 {
 112     m_refData = new wxRegionRefData();
 113 #ifdef __WXGTK20__
 114     M_REGIONDATA->m_region = gdk_region_copy( region );
 115 #else
 116     M_REGIONDATA->m_region = gdk_regions_union(wxGdkRegion(), region);
 117 #endif
 118 }
 119
 120 wxRegion::wxRegion( size_t n, const wxPoint *points, int fillStyle )
 121 {
 122     GdkPoint *gdkpoints = new GdkPoint[n];
 123     for ( size_t i = 0 ; i < n ; i++ )
 124     {
 125         gdkpoints[i].x = points[i].x;
 126         gdkpoints[i].y = points[i].y;
 127     }
 128
 129     m_refData = new wxRegionRefData();
 130
 131     GdkRegion* reg = gdk_region_polygon
 132                      (
 133                         gdkpoints,
 134                         n,
 135                         fillStyle == wxWINDING_RULE ? GDK_WINDING_RULE
 136                                                     : GDK_EVEN_ODD_RULE
 137                      );
 138
 139     M_REGIONDATA->m_region = reg;
 140
 141     delete [] gdkpoints;
 142 }
 143
 144 wxRegion::~wxRegion()
 145 {
 146     // m_refData unrefed in ~wxObject
 147 }
 148
 149 wxObjectRefData *wxRegion::CreateRefData() const
 150 {
 151     return new wxRegionRefData;
 152 }
 153
 154 wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
 155 {
 156     return new wxRegionRefData(*(wxRegionRefData *)data);
 157 }
 158
 159 // ----------------------------------------------------------------------------
 160 // wxRegion comparison
 161 // ----------------------------------------------------------------------------
 162
 163 bool wxRegion::operator==( const wxRegion& region ) const
 164 {
 165     if (m_refData == region.m_refData) return TRUE;
 166
 167     if (!m_refData || !region.m_refData) return FALSE;
 168
 169     // compare the regions themselves, not the pointers to ref data!
 170     return gdk_region_equal(M_REGIONDATA->m_region,
 171                             M_REGIONDATA_OF(region)->m_region);
 172 }
 173
 174 // ----------------------------------------------------------------------------
 175 // wxRegion operations
 176 // ----------------------------------------------------------------------------
 177
 178 void wxRegion::Clear()
 179 {
 180     UnRef();
 181 }
 182
 183 bool wxRegion::Union( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 184 {
 185     // workaround for a strange GTK/X11 bug: taking union with an empty
 186     // rectangle results in an empty region which is definitely not what we
 187     // want
 188     if ( !width || !height )
 189         return TRUE;
 190
 191     if ( !m_refData )
 192     {
 193         InitRect(x, y, width, height);
 194     }
 195     else
 196     {
 197         AllocExclusive();
 198
 199         GdkRectangle rect;
 200         rect.x = x;
 201         rect.y = y;
 202         rect.width = width;
 203         rect.height = height;
 204
 205 #ifdef __WXGTK20__
 206         gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
 207 #else
 208         GdkRegion *reg = gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
 209         gdk_region_destroy( M_REGIONDATA->m_region );
 210         M_REGIONDATA->m_region = reg;
 211 #endif
 212     }
 213
 214     return TRUE;
 215 }
 216
 217 bool wxRegion::Union( const wxRect& rect )
 218 {
 219     return Union( rect.x, rect.y, rect.width, rect.height );
 220 }
 221
 222 bool wxRegion::Union( const wxRegion& region )
 223 {
 224     if (region.IsNull())
 225         return FALSE;
 226
 227     if (!m_refData)
 228     {
 229         m_refData = new wxRegionRefData();
 230         M_REGIONDATA->m_region = gdk_region_new();
 231     }
 232     else
 233     {
 234         AllocExclusive();
 235     }
 236
 237 #ifdef __WXGTK20__
 238     gdk_region_union( M_REGIONDATA->m_region, region.GetRegion() );
 239 #else
 240     GdkRegion *reg = gdk_regions_union( M_REGIONDATA->m_region, region.GetRegion() );
 241     gdk_region_destroy( M_REGIONDATA->m_region );
 242     M_REGIONDATA->m_region = reg;
 243 #endif
 244
 245     return TRUE;
 246 }
 247
 248 bool wxRegion::Intersect( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 249 {
 250     wxRegion reg( x, y, width, height );
 251
 252     return Intersect( reg );
 253 }
 254
 255 bool wxRegion::Intersect( const wxRect& rect )
 256 {
 257     wxRegion reg( rect );
 258
 259     return Intersect( reg );
 260 }
 261
 262 bool wxRegion::Intersect( const wxRegion& region )
 263 {
 264     if (region.IsNull())
 265         return FALSE;
 266
 267     if (!m_refData)
 268     {
 269         // intersecting with invalid region doesn't make sense
 270         return FALSE;
 271     }
 272
 273     AllocExclusive();
 274
 275 #ifdef __WXGTK20__
 276     gdk_region_intersect( M_REGIONDATA->m_region, region.GetRegion() );
 277 #else
 278     GdkRegion *reg = gdk_regions_intersect( M_REGIONDATA->m_region, region.GetRegion() );
 279     gdk_region_destroy( M_REGIONDATA->m_region );
 280     M_REGIONDATA->m_region = reg;
 281 #endif
 282
 283     return TRUE;
 284 }
 285
 286 bool wxRegion::Subtract( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 287 {
 288     wxRegion reg( x, y, width, height );
 289     return Subtract( reg );
 290 }
 291
 292 bool wxRegion::Subtract( const wxRect& rect )
 293 {
 294     wxRegion reg( rect );
 295     return Subtract( reg );
 296 }
 297
 298 bool wxRegion::Subtract( const wxRegion& region )
 299 {
 300     if (region.IsNull())
 301         return FALSE;
 302
 303     if (!m_refData)
 304     {
 305         // subtracting from an invalid region doesn't make sense
 306         return FALSE;
 307     }
 308
 309     AllocExclusive();
 310
 311 #ifdef __WXGTK20__
 312     gdk_region_subtract( M_REGIONDATA->m_region, region.GetRegion() );
 313 #else
 314     GdkRegion *reg = gdk_regions_subtract( M_REGIONDATA->m_region, region.GetRegion() );
 315     gdk_region_destroy( M_REGIONDATA->m_region );
 316     M_REGIONDATA->m_region = reg;
 317 #endif
 318
 319     return TRUE;
 320 }
 321
 322 bool wxRegion::Xor( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 323 {
 324     wxRegion reg( x, y, width, height );
 325     return Xor( reg );
 326 }
 327
 328 bool wxRegion::Xor( const wxRect& rect )
 329 {
 330     wxRegion reg( rect );
 331     return Xor( reg );
 332 }
 333
 334 bool wxRegion::Xor( const wxRegion& region )
 335 {
 336     if (region.IsNull())
 337         return FALSE;
 338
 339     if (!m_refData)
 340     {
 341         return FALSE;
 342     }
 343
 344     AllocExclusive();
 345
 346 #ifdef __WXGTK20__
 347     gdk_region_xor( M_REGIONDATA->m_region, region.GetRegion() );
 348 #else
 349     GdkRegion *reg = gdk_regions_xor( M_REGIONDATA->m_region, region.GetRegion() );
 350     gdk_region_destroy( M_REGIONDATA->m_region );
 351     M_REGIONDATA->m_region = reg;
 352 #endif
 353
 354     return TRUE;
 355 }
 356
 357 bool wxRegion::Offset( wxCoord x, wxCoord y )
 358 {
 359     if (!m_refData)
 360         return FALSE;
 361
 362     AllocExclusive();
 363
 364     gdk_region_offset( M_REGIONDATA->m_region, x, y );
 365
 366     return TRUE;
 367 }
 368
 369 // ----------------------------------------------------------------------------
 370 // wxRegion tests
 371 // ----------------------------------------------------------------------------
 372
 373 void wxRegion::GetBox( wxCoord &x, wxCoord &y, wxCoord &w, wxCoord &h ) const
 374 {
 375     if ( m_refData )
 376     {
 377         GdkRectangle rect;
 378         gdk_region_get_clipbox( M_REGIONDATA->m_region, &rect );
 379         x = rect.x;
 380         y = rect.y;
 381         w = rect.width;
 382         h = rect.height;
 383     }
 384     else
 385     {
 386         x = 0;
 387         y = 0;
 388         w = -1;
 389         h = -1;
 390     }
 391 }
 392
 393 wxRect wxRegion::GetBox() const
 394 {
 395     wxCoord x, y, w, h;
 396     GetBox( x, y, w, h );
 397     return wxRect( x, y, w, h );
 398 }
 399
 400 bool wxRegion::Empty() const
 401 {
 402     if (!m_refData)
 403         return TRUE;
 404
 405     return gdk_region_empty( M_REGIONDATA->m_region );
 406 }
 407
 408 wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y ) const
 409 {
 410     if (!m_refData)
 411         return wxOutRegion;
 412
 413     if (gdk_region_point_in( M_REGIONDATA->m_region, x, y ))
 414         return wxInRegion;
 415     else
 416         return wxOutRegion;
 417 }
 418
 419 wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) const
 420 {
 421     if (!m_refData)
 422         return wxOutRegion;
 423
 424     GdkRectangle rect;
 425     rect.x = x;
 426     rect.y = y;
 427     rect.width = w;
 428     rect.height = h;
 429     GdkOverlapType res = gdk_region_rect_in( M_REGIONDATA->m_region, &rect );
 430     switch (res)
 431     {
 432         case GDK_OVERLAP_RECTANGLE_IN:   return wxInRegion;
 433         case GDK_OVERLAP_RECTANGLE_OUT:  return wxOutRegion;
 434         case GDK_OVERLAP_RECTANGLE_PART: return wxPartRegion;
 435     }
 436     return wxOutRegion;
 437 }
 438
 439 wxRegionContain wxRegion::Contains(const wxPoint& pt) const
 440 {
 441     return Contains( pt.x, pt.y );
 442 }
 443
 444 wxRegionContain wxRegion::Contains(const wxRect& rect) const
 445 {
 446     return Contains( rect.x, rect.y, rect.width, rect.height );
 447 }
 448
 449 GdkRegion *wxRegion::GetRegion() const
 450 {
 451     if (!m_refData)
 452         return (GdkRegion*) NULL;
 453
 454     return M_REGIONDATA->m_region;
 455 }
 456
 457 // ----------------------------------------------------------------------------
 458 // wxRegionIterator
 459 // ----------------------------------------------------------------------------
 460
 461 #ifndef __WXGTK20__
 462
 463 // the following structures must match the private structures
 464 // in X11 region code ( xc/lib/X11/region.h )
 465
 466 // this makes the Region type transparent
 467 // and we have access to the region rectangles
 468
 469 #include <gdk/gdkprivate.h>
 470
 471 struct _XBox {
 472     short x1, x2, y1, y2;
 473 };
 474
 475 struct _XRegion {
 476     long   size , numRects;
 477     _XBox *rects, extents;
 478 };
 479
 480 #endif // GTK+ 1.x
 481
 482 class wxRIRefData: public wxObjectRefData
 483 {
 484 public:
 485     wxRIRefData() { Init(); }
 486     virtual ~wxRIRefData();
 487
 488     void CreateRects( const wxRegion& r );
 489
 490     void Init() { m_rects = NULL; m_numRects = 0; }
 491
 492     wxRect *m_rects;
 493     size_t  m_numRects;
 494 };
 495
 496 wxRIRefData::~wxRIRefData()
 497 {
 498     delete [] m_rects;
 499 }
 500
 501 void wxRIRefData::CreateRects( const wxRegion& region )
 502 {
 503     delete [] m_rects;
 504
 505     Init();
 506
 507     GdkRegion *gdkregion = region.GetRegion();
 508     if (!gdkregion)
 509         return;
 510
 511 #ifdef __WXGTK20__
 512     GdkRectangle *gdkrects = NULL;
 513     gint numRects = 0;
 514     gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects );
 515
 516     m_numRects = numRects;
 517     if (numRects)
 518     {
 519         m_rects = new wxRect[m_numRects];
 520         for (size_t i=0; i < m_numRects; ++i)
 521         {
 522             GdkRectangle &gr = gdkrects[i];
 523             wxRect &wr = m_rects[i];
 524             wr.x = gr.x;
 525             wr.y = gr.y;
 526             wr.width = gr.width;
 527             wr.height = gr.height;
 528         }
 529     }
 530     g_free( gdkrects );
 531 #else // GTK+ 1.x
 532     Region r = ((GdkRegionPrivate *)gdkregion)->xregion;
 533     if (r)
 534     {
 535         m_numRects = r->numRects;
 536         if (m_numRects)
 537         {
 538             m_rects = new wxRect[m_numRects];
 539             for (size_t i=0; i < m_numRects; ++i)
 540             {
 541                 _XBox &xr = r->rects[i];
 542                 wxRect &wr = m_rects[i];
 543                 wr.x = xr.x1;
 544                 wr.y = xr.y1;
 545                 wr.width = xr.x2-xr.x1;
 546                 wr.height = xr.y2-xr.y1;
 547             }
 548         }
 549     }
 550 #endif // GTK+ 2.0/1.x
 551 }
 552
 553 wxRegionIterator::wxRegionIterator()
 554 {
 555     m_refData = new wxRIRefData();
 556     Reset();
 557 }
 558
 559 wxRegionIterator::wxRegionIterator( const wxRegion& region )
 560 {
 561     m_refData = new wxRIRefData();
 562     Reset(region);
 563 }
 564
 565 void wxRegionIterator::Reset( const wxRegion& region )
 566 {
 567     m_region = region;
 568     ((wxRIRefData*)m_refData)->CreateRects(region);
 569     Reset();
 570 }
 571
 572 bool wxRegionIterator::HaveRects() const
 573 {
 574     return m_current < ((wxRIRefData*)m_refData)->m_numRects;
 575 }
 576
 577 wxRegionIterator& wxRegionIterator::operator ++ ()
 578 {
 579     if (HaveRects())
 580         ++m_current;
 581
 582     return *this;
 583 }
 584
 585 wxRegionIterator wxRegionIterator::operator ++ (int)
 586 {
 587     wxRegionIterator tmp = *this;
 588     if (HaveRects())
 589         ++m_current;
 590
 591     return tmp;
 592 }
 593
 594 wxCoord wxRegionIterator::GetX() const
 595 {
 596     wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
 597
 598     return ((wxRIRefData*)m_refData)->m_rects[m_current].x;
 599 }
 600
 601 wxCoord wxRegionIterator::GetY() const
 602 {
 603     wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
 604
 605     return ((wxRIRefData*)m_refData)->m_rects[m_current].y;
 606 }
 607
 608 wxCoord wxRegionIterator::GetW() const
 609 {
 610     wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
 611
 612     return ((wxRIRefData*)m_refData)->m_rects[m_current].width;
 613 }
 614
 615 wxCoord wxRegionIterator::GetH() const
 616 {
 617     wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
 618
 619     return ((wxRIRefData*)m_refData)->m_rects[m_current].height;
 620 }
 621
 622 wxRect wxRegionIterator::GetRect() const
 623 {
 624     wxRect r;
 625     if( HaveRects() )
 626         r = ((wxRIRefData*)m_refData)->m_rects[m_current];
 627
 628     return r;
 629 }
 630