Add test for absence of events from wxSpinCtrlDouble ctor.

[wxWidgets.git] / src / generic / regiong.cpp

diff --git a/src/generic/regiong.cpp b/src/generic/regiong.cpp
index 4ed586112c282b58058ec22c022a49cbec4f64b3..7580c44432d49b29450042da5c5c8f62eb2bd7c9 100644 (file)
--- a/src/generic/regiong.cpp
+++ b/src/generic/regiong.cpp
@@ -1,16 +1,26 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        generic/region.cpp
+// Name:        src/generic/regiong.cpp

 // Purpose:     generic wxRegion class
 // Author:      David Elliott
 // Modified by:
 // Created:     2004/04/12
 // Purpose:     generic wxRegion class
 // Author:      David Elliott
 // Modified by:
 // Created:     2004/04/12

-// RCS-ID:      $Id$

 // Copyright:   (c) 2004 David Elliott
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Copyright:   (c) 2004 David Elliott
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#include "wx/generic/region.h"
-#include "wx/utils.h"
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#include "wx/region.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/utils.h"
+#endif

 
 // ========================================================================
 // Classes to interface with X.org code
 
 // ========================================================================
 // Classes to interface with X.org code


@@ -28,6 +38,7 @@ struct REGION
 public:
     // Default constructor initializes nothing
     REGION() {}
 public:
     // Default constructor initializes nothing
     REGION() {}

+

     REGION(const wxRect& rect)
     {
         rects = &extents;
     REGION(const wxRect& rect)
     {
         rects = &extents;


@@ -38,7 +49,11 @@ public:
         extents.y2 = rect.y + rect.height;
         size = 1;
     }
         extents.y2 = rect.y + rect.height;
         size = 1;
     }

-    BoxPtr GetBox(int i) { if(i<numRects) return rects+i; else return NULL; }
+
+    BoxPtr GetBox(int i)
+    {
+        return i < numRects ? rects + i : NULL;
+    }

 
     // X.org methods
     static bool XClipBox(
 
     // X.org methods
     static bool XClipBox(


@@ -159,12 +174,16 @@ protected:
 // ========================================================================
 // wxRegionRefData
 // ========================================================================
 // ========================================================================
 // wxRegionRefData
 // ========================================================================

-class wxRegionRefData : public wxObjectRefData, public REGION
+
+class wxRegionRefData : public wxGDIRefData,
+                        public REGION

 {
 public:
     wxRegionRefData()
 {
 public:
     wxRegionRefData()

-    /* XCreateRegion */
-    {   size = 1;
+        : wxGDIRefData(),
+          REGION()
+    {
+        size = 1;

         numRects = 0;
         rects = ( BOX * )malloc( (unsigned) sizeof( BOX ));
         extents.x1 = 0;
         numRects = 0;
         rects = ( BOX * )malloc( (unsigned) sizeof( BOX ));
         extents.x1 = 0;


@@ -172,10 +191,12 @@ public:
         extents.y1 = 0;
         extents.y2 = 0;
     }
         extents.y1 = 0;
         extents.y2 = 0;
     }

+

     wxRegionRefData(const wxPoint& topLeft, const wxPoint& bottomRight)
     wxRegionRefData(const wxPoint& topLeft, const wxPoint& bottomRight)

-    :   wxObjectRefData()
-    ,   REGION()
-    {   rects = (BOX*)malloc(sizeof(BOX));
+        : wxGDIRefData(),
+          REGION()
+    {
+        rects = (BOX*)malloc(sizeof(BOX));

         size = 1;
         numRects = 1;
         extents.x1 = topLeft.x;
         size = 1;
         numRects = 1;
         extents.x1 = topLeft.x;


@@ -184,25 +205,31 @@ public:
         extents.y2 = bottomRight.y;
         *rects = extents;
     }
         extents.y2 = bottomRight.y;
         *rects = extents;
     }

+

     wxRegionRefData(const wxRect& rect)
     wxRegionRefData(const wxRect& rect)

-    :   wxObjectRefData()
-    ,   REGION(rect)
-    {   rects = (BOX*)malloc(sizeof(BOX));
+        : wxGDIRefData(),
+          REGION(rect)
+    {
+        rects = (BOX*)malloc(sizeof(BOX));

         *rects = extents;
     }
         *rects = extents;
     }

+

     wxRegionRefData(const wxRegionRefData& refData)
     wxRegionRefData(const wxRegionRefData& refData)

-    :   wxObjectRefData()
-    ,   REGION()
+        : wxGDIRefData(),
+          REGION()

     {
         size = refData.size;
         numRects = refData.numRects;
         rects = (Box*)malloc(numRects*sizeof(Box));
     {
         size = refData.size;
         numRects = refData.numRects;
         rects = (Box*)malloc(numRects*sizeof(Box));

+        memcpy(rects, refData.rects, numRects*sizeof(Box));

         extents = refData.extents;
     }
         extents = refData.extents;
     }

-    ~wxRegionRefData()
+
+    virtual ~wxRegionRefData()

     {
         free(rects);
     }
     {
         free(rects);
     }

+

 private:
     // Don't allow this
     wxRegionRefData(const REGION&);
 private:
     // Don't allow this
     wxRegionRefData(const REGION&);


@@ -211,7 +238,7 @@ private:
 // ========================================================================
 // wxRegionGeneric
 // ========================================================================
 // ========================================================================
 // wxRegionGeneric
 // ========================================================================

-//IMPLEMENT_DYNAMIC_CLASS(wxRegionGeneric, wxGDIObject);
+//IMPLEMENT_DYNAMIC_CLASS(wxRegionGeneric, wxGDIObject)

 
 #define M_REGIONDATA ((wxRegionRefData *)m_refData)
 #define M_REGIONDATA_OF(rgn) ((wxRegionRefData *)(rgn.m_refData))
 
 #define M_REGIONDATA ((wxRegionRefData *)m_refData)
 #define M_REGIONDATA_OF(rgn) ((wxRegionRefData *)(rgn.m_refData))


@@ -243,115 +270,104 @@ wxRegionGeneric::wxRegionGeneric(const wxPoint& topLeft, const wxPoint& bottomRi
     m_refData = new wxRegionRefData(topLeft, bottomRight);
 }
 
     m_refData = new wxRegionRefData(topLeft, bottomRight);
 }
 

+wxRegionGeneric::wxRegionGeneric(const wxBitmap& bmp)
+{
+    wxFAIL_MSG("NOT IMPLEMENTED: wxRegionGeneric::wxRegionGeneric(const wxBitmap& bmp)");
+}
+
+wxRegionGeneric::wxRegionGeneric(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle)
+{
+    wxFAIL_MSG("NOT IMPLEMENTED: wxRegionGeneric::wxRegionGeneric(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle)");
+}
+
+wxRegionGeneric::wxRegionGeneric(const wxBitmap& bmp, const wxColour& transp, int tolerance)
+{
+    wxFAIL_MSG("NOT IMPLEMENTED: wxRegionGeneric::wxRegionGeneric(const wxBitmap& bmp, const wxColour& transp, int tolerance)");
+}
+

 void wxRegionGeneric::Clear()
 {
     UnRef();
 void wxRegionGeneric::Clear()
 {
     UnRef();

+    if (!m_refData)
+        m_refData = new wxRegionRefData(wxRect(0,0,0,0));

 }
 
 }
 

-wxObjectRefData *wxRegionGeneric::CreateRefData() const
+wxGDIRefData *wxRegionGeneric::CreateGDIRefData() const

 {
     return new wxRegionRefData;
 }
 
 {
     return new wxRegionRefData;
 }
 

-wxObjectRefData *wxRegionGeneric::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegionGeneric::CloneGDIRefData(const wxGDIRefData *data) const

 {
     return new wxRegionRefData(*(wxRegionRefData *)data);
 }
 
 {
     return new wxRegionRefData(*(wxRegionRefData *)data);
 }
 

-bool wxRegionGeneric::operator== (const wxRegionGeneric& region)
+bool wxRegionGeneric::DoIsEqual(const wxRegion& region) const

 {
 {

-    wxASSERT(m_refData && region.m_refData);

     return REGION::XEqualRegion(M_REGIONDATA,M_REGIONDATA_OF(region));
 }
 
     return REGION::XEqualRegion(M_REGIONDATA,M_REGIONDATA_OF(region));
 }
 

-wxRect wxRegionGeneric::GetBox() const
+bool wxRegionGeneric::DoGetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const

 {
 {

-    wxASSERT(m_refData);
-    wxRect rect;
-    REGION::XClipBox(M_REGIONDATA,&rect);
-    return rect;
-}
+    if ( !m_refData )
+        return false;

 
 

-void wxRegionGeneric::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const
-{
-    wxASSERT(m_refData);

     wxRect rect;
     REGION::XClipBox(M_REGIONDATA,&rect);
     x = rect.x;
     y = rect.y;
     w = rect.width;
     h = rect.height;
     wxRect rect;
     REGION::XClipBox(M_REGIONDATA,&rect);
     x = rect.x;
     y = rect.y;
     w = rect.width;
     h = rect.height;

+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // wxRegionGeneric operations
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxRegionGeneric operations
 // ----------------------------------------------------------------------------
 

-bool wxRegionGeneric::Union(const wxRect& rect)
-/* XUnionRectWithRegion */
+bool wxRegionGeneric::DoUnionWithRect(const wxRect& rect)

 {
 {

-    if (!rect.width || !rect.height)
-        return false;
+    if ( rect.IsEmpty() )
+    {
+        // nothing to do
+        return true;
+    }

 
     AllocExclusive();
     REGION region(rect);
     return REGION::XUnionRegion(&region,M_REGIONDATA,M_REGIONDATA);
 }
 
 
     AllocExclusive();
     REGION region(rect);
     return REGION::XUnionRegion(&region,M_REGIONDATA,M_REGIONDATA);
 }
 

-bool wxRegionGeneric::Union(const wxRegionGeneric& region)
+bool wxRegionGeneric::DoUnionWithRegion(const wxRegion& region)

 {
     AllocExclusive();
     return REGION::XUnionRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 
 {
     AllocExclusive();
     return REGION::XUnionRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 

-bool wxRegionGeneric::Intersect(const wxRect& rect)
-{
-    if (!rect.width || !rect.height)
-        return false;
-    AllocExclusive();
-    REGION region(rect);
-
-    return REGION::XIntersectRegion(&region,M_REGIONDATA,M_REGIONDATA);
-}
-
-bool wxRegionGeneric::Intersect(const wxRegionGeneric& region)
+bool wxRegionGeneric::DoIntersect(const wxRegion& region)

 {
     AllocExclusive();
     return REGION::XIntersectRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 
 {
     AllocExclusive();
     return REGION::XIntersectRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 

-bool wxRegionGeneric::Subtract(const wxRect& rect)
+bool wxRegionGeneric::DoSubtract(const wxRegion& region)

 {
 {

-    if (!rect.width || !rect.height)
-        return false;
-    AllocExclusive();
-    REGION region(rect);
-
-    return REGION::XSubtractRegion(&region,M_REGIONDATA,M_REGIONDATA);
-}
+    if ( region.IsEmpty() )
+    {
+        // nothing to do
+        return true;
+    }

 
 

-bool wxRegionGeneric::Subtract(const wxRegionGeneric& region)
-{

     return REGION::XSubtractRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 
     return REGION::XSubtractRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 

-bool wxRegionGeneric::Xor(const wxRect& rect)
-{
-    if (!rect.width || !rect.height)
-        return false;
-    AllocExclusive();
-    REGION region(rect);
-
-    return REGION::XXorRegion(&region,M_REGIONDATA,M_REGIONDATA);
-}
-
-bool wxRegionGeneric::Xor(const wxRegionGeneric& region)
+bool wxRegionGeneric::DoXor(const wxRegion& region)

 {
     AllocExclusive();
     return REGION::XXorRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 
 {
     AllocExclusive();
     return REGION::XXorRegion(M_REGIONDATA_OF(region),M_REGIONDATA,M_REGIONDATA);
 }
 

-bool wxRegionGeneric::Offset(wxCoord x, wxCoord y)
+bool wxRegionGeneric::DoOffset(wxCoord x, wxCoord y)

 {
     AllocExclusive();
     return REGION::XOffsetRegion(M_REGIONDATA, x, y);
 {
     AllocExclusive();
     return REGION::XOffsetRegion(M_REGIONDATA, x, y);


@@ -361,35 +377,21 @@ bool wxRegionGeneric::Offset(wxCoord x, wxCoord y)
 // wxRegionGeneric comparison
 // ----------------------------------------------------------------------------
 
 // wxRegionGeneric comparison
 // ----------------------------------------------------------------------------
 

-bool wxRegionGeneric::Empty() const
+bool wxRegionGeneric::IsEmpty() const

 {
     wxASSERT(m_refData);
     return REGION::XEmptyRegion(M_REGIONDATA);
 }
 
 // Does the region contain the point (x,y)?
 {
     wxASSERT(m_refData);
     return REGION::XEmptyRegion(M_REGIONDATA);
 }
 
 // Does the region contain the point (x,y)?

-wxRegionContain wxRegionGeneric::Contains(long x, long y) const
+wxRegionContain wxRegionGeneric::DoContainsPoint(wxCoord x, wxCoord y) const

 {
     wxASSERT(m_refData);
 {
     wxASSERT(m_refData);

-    return REGION::XPointInRegion(M_REGIONDATA,x,y)?wxInRegion:wxOutRegion;
-}
-
-// Does the region contain the point pt?
-wxRegionContain wxRegionGeneric::Contains(const wxPoint& pt) const
-{
-    wxASSERT(m_refData);
-    return REGION::XPointInRegion(M_REGIONDATA,pt.x,pt.y)?wxInRegion:wxOutRegion;
-}
-
-// Does the region contain the rectangle (x, y, w, h)?
-wxRegionContain wxRegionGeneric::Contains(long x, long y, long w, long h) const
-{
-    wxASSERT(m_refData);
-    return REGION::XRectInRegion(M_REGIONDATA,x,y,w,h);
+    return REGION::XPointInRegion(M_REGIONDATA,x,y) ? wxInRegion : wxOutRegion;

 }
 
 // Does the region contain the rectangle rect?
 }
 
 // Does the region contain the rectangle rect?

-wxRegionContain wxRegionGeneric::Contains(const wxRect& rect) const
+wxRegionContain wxRegionGeneric::DoContainsRect(const wxRect& rect) const

 {
     wxASSERT(m_refData);
     return REGION::XRectInRegion(M_REGIONDATA,rect.x,rect.y,rect.width,rect.height);
 {
     wxASSERT(m_refData);
     return REGION::XRectInRegion(M_REGIONDATA,rect.x,rect.y,rect.width,rect.height);


@@ -398,7 +400,7 @@ wxRegionContain wxRegionGeneric::Contains(const wxRect& rect) const
 // ========================================================================
 // wxRegionIteratorGeneric
 // ========================================================================
 // ========================================================================
 // wxRegionIteratorGeneric
 // ========================================================================

-//IMPLEMENT_DYNAMIC_CLASS(wxRegionIteratorGeneric,wxObject);
+//IMPLEMENT_DYNAMIC_CLASS(wxRegionIteratorGeneric,wxObject)

 
 wxRegionIteratorGeneric::wxRegionIteratorGeneric()
 {
 
 wxRegionIteratorGeneric::wxRegionIteratorGeneric()
 {


@@ -443,7 +445,7 @@ wxRegionIteratorGeneric wxRegionIteratorGeneric::operator++(int)
 
 wxRect wxRegionIteratorGeneric::GetRect() const
 {
 
 wxRect wxRegionIteratorGeneric::GetRect() const
 {

-    wxASSERT(m_refData);
+    wxASSERT(m_region.m_refData);

     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return wxRect
     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return wxRect


@@ -456,7 +458,7 @@ wxRect wxRegionIteratorGeneric::GetRect() const
 
 long wxRegionIteratorGeneric::GetX() const
 {
 
 long wxRegionIteratorGeneric::GetX() const
 {

-    wxASSERT(m_refData);
+    wxASSERT(m_region.m_refData);

     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->x1;
     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->x1;


@@ -464,7 +466,7 @@ long wxRegionIteratorGeneric::GetX() const
 
 long wxRegionIteratorGeneric::GetY() const
 {
 
 long wxRegionIteratorGeneric::GetY() const
 {

-    wxASSERT(m_refData);
+    wxASSERT(m_region.m_refData);

     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->y1;
     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->y1;


@@ -472,7 +474,7 @@ long wxRegionIteratorGeneric::GetY() const
 
 long wxRegionIteratorGeneric::GetW() const
 {
 
 long wxRegionIteratorGeneric::GetW() const
 {

-    wxASSERT(m_refData);
+    wxASSERT(m_region.m_refData);

     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->x2 - box->x1;
     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->x2 - box->x1;


@@ -480,7 +482,7 @@ long wxRegionIteratorGeneric::GetW() const
 
 long wxRegionIteratorGeneric::GetH() const
 {
 
 long wxRegionIteratorGeneric::GetH() const
 {

-    wxASSERT(m_refData);
+    wxASSERT(m_region.m_refData);

     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->y2 - box->y1;
     const Box *box = M_REGIONDATA_OF(m_region)->GetBox(m_current);
     wxASSERT(box);
     return box->y2 - box->y1;


@@ -603,15 +605,18 @@ SOFTWARE.
  */
 
 /* Create a new empty region */
  */
 
 /* Create a new empty region */

-Region REGION::
-XCreateRegion(void)
+Region REGION::XCreateRegion(void)

 {
 {

-    Region temp;
+    Region temp = new REGION;

 
 

-    if (! (temp = new REGION))
+    if (!temp)

         return (Region) NULL;
         return (Region) NULL;

-    if (! (temp->rects = ( BOX * )malloc( (unsigned) sizeof( BOX )))) {
-        free((char *) temp);
+
+    temp->rects = ( BOX * )malloc( (unsigned) sizeof( BOX ));
+
+    if (!temp->rects)
+    {
+        delete temp;

         return (Region) NULL;
     }
     temp->numRects = 0;
         return (Region) NULL;
     }
     temp->numRects = 0;


@@ -623,10 +628,7 @@ XCreateRegion(void)
     return( temp );
 }
 
     return( temp );
 }
 

-bool REGION::
-XClipBox(
-    Region r,
-    wxRect *rect)
+bool REGION::XClipBox(Region r, wxRect *rect)

 {
     rect->x = r->extents.x1;
     rect->y = r->extents.y1;
 {
     rect->x = r->extents.x1;
     rect->y = r->extents.y1;


@@ -682,7 +684,7 @@ miSetExtents (Region pReg)
     pExtents->x2 = pBoxEnd->x2;
     pExtents->y2 = pBoxEnd->y2;
 
     pExtents->x2 = pBoxEnd->x2;
     pExtents->y2 = pBoxEnd->y2;
 

-    assert(pExtents->y1 < pExtents->y2);
+    wxASSERT_LEVEL_2(pExtents->y1 < pExtents->y2);

     while (pBox <= pBoxEnd)
     {
         if (pBox->x1 < pExtents->x1)
     while (pBox <= pBoxEnd)
     {
         if (pBox->x1 < pExtents->x1)


@@ -695,7 +697,7 @@ miSetExtents (Region pReg)
         }
         pBox++;
     }
         }
         pBox++;
     }

-    assert(pExtents->x1 < pExtents->x2);
+    wxASSERT_LEVEL_2(pExtents->x1 < pExtents->x2);

 }
 
 bool REGION::
 }
 
 bool REGION::


@@ -786,7 +788,7 @@ miIntersectO (
          */
         if (x1 < x2)
         {
          */
         if (x1 < x2)
         {

-            assert(y1<y2);
+            wxASSERT_LEVEL_2(y1<y2);

 
             MEMCHECK(pReg, pNextRect, pReg->rects);
             pNextRect->x1 = x1;
 
             MEMCHECK(pReg, pNextRect, pReg->rects);
             pNextRect->x1 = x1;


@@ -795,7 +797,7 @@ miIntersectO (
             pNextRect->y2 = y2;
             pReg->numRects += 1;
             pNextRect++;
             pNextRect->y2 = y2;
             pReg->numRects += 1;
             pNextRect++;

-            assert(pReg->numRects <= pReg->size);
+            wxASSERT_LEVEL_2(pReg->numRects <= pReg->size);

         }
 
         /*
         }
 
         /*


@@ -859,9 +861,10 @@ miRegionCopy(
             {
                 BOX *prevRects = dstrgn->rects;
 
             {
                 BOX *prevRects = dstrgn->rects;
 

-                if (! (dstrgn->rects = (BOX *)
+                dstrgn->rects = (BOX *)

                        realloc((char *) dstrgn->rects,
                        realloc((char *) dstrgn->rects,

-                               (unsigned) rgn->numRects * (sizeof(BOX)))))
+                               (unsigned) rgn->numRects * (sizeof(BOX)));
+                if (!dstrgn->rects)

                 {
                     free(prevRects);
                     return;
                 {
                     free(prevRects);
                     return;


@@ -1128,8 +1131,10 @@ miRegionOp(
      */
     newReg->size = wxMax(reg1->numRects,reg2->numRects) * 2;
 
      */
     newReg->size = wxMax(reg1->numRects,reg2->numRects) * 2;
 

-    if (! (newReg->rects = (BoxPtr)
-           malloc ((unsigned) (sizeof(BoxRec) * newReg->size)))) {
+    newReg->rects = (BoxPtr)malloc((unsigned) (sizeof(BoxRec) * newReg->size));
+
+    if (!newReg->rects)
+    {

         newReg->size = 0;
         return;
     }
         newReg->size = 0;
         return;
     }


@@ -1373,11 +1378,11 @@ miUnionNonO (
 
     pNextRect = &pReg->rects[pReg->numRects];
 
 
     pNextRect = &pReg->rects[pReg->numRects];
 

-    assert(y1 < y2);
+    wxASSERT_LEVEL_2(y1 < y2);

 
     while (r != rEnd)
     {
 
     while (r != rEnd)
     {

-        assert(r->x1 < r->x2);
+        wxASSERT_LEVEL_2(r->x1 < r->x2);

         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = r->x1;
         pNextRect->y1 = y1;
         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = r->x1;
         pNextRect->y1 = y1;


@@ -1386,7 +1391,7 @@ miUnionNonO (
         pReg->numRects += 1;
         pNextRect++;
 
         pReg->numRects += 1;
         pNextRect++;
 

-        assert(pReg->numRects<=pReg->size);
+        wxASSERT_LEVEL_2(pReg->numRects<=pReg->size);

         r++;
     }
     return 0;        /* lint */
         r++;
     }
     return 0;        /* lint */


@@ -1433,7 +1438,7 @@ miUnionO (
         if (pNextRect[-1].x2 < r->x2)  \
         {  \
             pNextRect[-1].x2 = r->x2;  \
         if (pNextRect[-1].x2 < r->x2)  \
         {  \
             pNextRect[-1].x2 = r->x2;  \

-            assert(pNextRect[-1].x1<pNextRect[-1].x2); \
+            wxASSERT_LEVEL_2(pNextRect[-1].x1<pNextRect[-1].x2); \

         }  \
     }  \
     else  \
         }  \
     }  \
     else  \


@@ -1446,10 +1451,10 @@ miUnionO (
         pReg->numRects += 1;  \
         pNextRect += 1;  \
     }  \
         pReg->numRects += 1;  \
         pNextRect += 1;  \
     }  \

-    assert(pReg->numRects<=pReg->size);\
+    wxASSERT_LEVEL_2(pReg->numRects<=pReg->size);\

     r++;
 
     r++;
 

-    assert (y1<y2);
+    wxASSERT_LEVEL_2 (y1<y2);

     while ((r1 != r1End) && (r2 != r2End))
     {
         if (r1->x1 < r2->x1)
     while ((r1 != r1End) && (r2 != r2End))
     {
         if (r1->x1 < r2->x1)


@@ -1574,11 +1579,11 @@ miSubtractNonO1 (
 
     pNextRect = &pReg->rects[pReg->numRects];
 
 
     pNextRect = &pReg->rects[pReg->numRects];
 

-    assert(y1<y2);
+    wxASSERT_LEVEL_2(y1<y2);

 
     while (r != rEnd)
     {
 
     while (r != rEnd)
     {

-        assert(r->x1<r->x2);
+        wxASSERT_LEVEL_2(r->x1<r->x2);

         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = r->x1;
         pNextRect->y1 = y1;
         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = r->x1;
         pNextRect->y1 = y1;


@@ -1587,7 +1592,7 @@ miSubtractNonO1 (
         pReg->numRects += 1;
         pNextRect++;
 
         pReg->numRects += 1;
         pNextRect++;
 

-        assert(pReg->numRects <= pReg->size);
+        wxASSERT_LEVEL_2(pReg->numRects <= pReg->size);

 
         r++;
     }
 
         r++;
     }


@@ -1624,7 +1629,7 @@ miSubtractO (
 
     x1 = r1->x1;
 
 
     x1 = r1->x1;
 

-    assert(y1<y2);
+    wxASSERT_LEVEL_2(y1<y2);

     pNextRect = &pReg->rects[pReg->numRects];
 
     while ((r1 != r1End) && (r2 != r2End))
     pNextRect = &pReg->rects[pReg->numRects];
 
     while ((r1 != r1End) && (r2 != r2End))


@@ -1639,7 +1644,7 @@ miSubtractO (
         else if (r2->x1 <= x1)
         {
             /*
         else if (r2->x1 <= x1)
         {
             /*

-             * Subtrahend preceeds minuend: nuke left edge of minuend.
+             * Subtrahend precedes minuend: nuke left edge of minuend.

              */
             x1 = r2->x2;
             if (x1 >= r1->x2)
              */
             x1 = r2->x2;
             if (x1 >= r1->x2)


@@ -1667,7 +1672,7 @@ miSubtractO (
              * Left part of subtrahend covers part of minuend: add uncovered
              * part of minuend to region and skip to next subtrahend.
              */
              * Left part of subtrahend covers part of minuend: add uncovered
              * part of minuend to region and skip to next subtrahend.
              */

-            assert(x1<r2->x1);
+            wxASSERT_LEVEL_2(x1<r2->x1);

             MEMCHECK(pReg, pNextRect, pReg->rects);
             pNextRect->x1 = x1;
             pNextRect->y1 = y1;
             MEMCHECK(pReg, pNextRect, pReg->rects);
             pNextRect->x1 = x1;
             pNextRect->y1 = y1;


@@ -1676,7 +1681,7 @@ miSubtractO (
             pReg->numRects += 1;
             pNextRect++;
 
             pReg->numRects += 1;
             pNextRect++;
 

-            assert(pReg->numRects<=pReg->size);
+            wxASSERT_LEVEL_2(pReg->numRects<=pReg->size);

 
             x1 = r2->x2;
             if (x1 >= r1->x2)
 
             x1 = r2->x2;
             if (x1 >= r1->x2)


@@ -1710,7 +1715,7 @@ miSubtractO (
                 pNextRect->y2 = y2;
                 pReg->numRects += 1;
                 pNextRect++;
                 pNextRect->y2 = y2;
                 pReg->numRects += 1;
                 pNextRect++;

-                assert(pReg->numRects<=pReg->size);
+                wxASSERT_LEVEL_2(pReg->numRects<=pReg->size);

             }
             r1++;
             if (r1 != r1End)
             }
             r1++;
             if (r1 != r1End)


@@ -1723,7 +1728,7 @@ miSubtractO (
      */
     while (r1 != r1End)
     {
      */
     while (r1 != r1End)
     {

-        assert(x1<r1->x2);
+        wxASSERT_LEVEL_2(x1<r1->x2);

         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = x1;
         pNextRect->y1 = y1;
         MEMCHECK(pReg, pNextRect, pReg->rects);
         pNextRect->x1 = x1;
         pNextRect->y1 = y1;


@@ -1732,7 +1737,7 @@ miSubtractO (
         pReg->numRects += 1;
         pNextRect++;
 
         pReg->numRects += 1;
         pNextRect++;
 

-        assert(pReg->numRects<=pReg->size);
+        wxASSERT_LEVEL_2(pReg->numRects<=pReg->size);

 
         r1++;
         if (r1 != r1End)
 
         r1++;
         if (r1 != r1End)


@@ -1758,11 +1763,7 @@ miSubtractO (
  *-----------------------------------------------------------------------
  */
 
  *-----------------------------------------------------------------------
  */
 

-bool REGION::
-XSubtractRegion(
-    Region                   regM,
-    Region                  regS,
-    register Region        regD)
+bool REGION::XSubtractRegion(Region regM, Region regS, register Region regD)

 {
    /* check for trivial reject */
     if ( (!(regM->numRects)) || (!(regS->numRects))  ||
 {
    /* check for trivial reject */
     if ( (!(regM->numRects)) || (!(regS->numRects))  ||


@@ -1786,13 +1787,16 @@ XSubtractRegion(
     return true;
 }
 
     return true;
 }
 

-bool REGION::
-XXorRegion(Region sra, Region srb, Region dr)
+bool REGION::XXorRegion(Region sra, Region srb, Region dr)

 {
 {

-    Region tra, trb;
+    Region tra = XCreateRegion();
+
+    wxCHECK_MSG( tra, false, wxT("region not created") );
+
+    Region trb = XCreateRegion();
+
+    wxCHECK_MSG( trb, false, wxT("region not created") );

 
 

-    if ((! (tra = XCreateRegion())) || (! (trb = XCreateRegion())))
-        return 0;

     (void) XSubtractRegion(sra,srb,tra);
     (void) XSubtractRegion(srb,sra,trb);
     (void) XUnionRegion(tra,trb,dr);
     (void) XSubtractRegion(sra,srb,tra);
     (void) XSubtractRegion(srb,sra,trb);
     (void) XUnionRegion(tra,trb,dr);


@@ -1805,9 +1809,7 @@ XXorRegion(Region sra, Region srb, Region dr)
  * Check to see if the region is empty.  Assumes a region is passed
  * as a parameter
  */
  * Check to see if the region is empty.  Assumes a region is passed
  * as a parameter
  */

-bool REGION::
-XEmptyRegion(
-    Region r)
+bool REGION::XEmptyRegion(Region r)

 {
     if( r->numRects == 0 ) return true;
     else  return false;
 {
     if( r->numRects == 0 ) return true;
     else  return false;


@@ -1816,8 +1818,7 @@ XEmptyRegion(
 /*
  *        Check to see if two regions are equal
  */
 /*
  *        Check to see if two regions are equal
  */

-bool REGION::
-XEqualRegion(Region r1, Region r2)
+bool REGION::XEqualRegion(Region r1, Region r2)

 {
     int i;
 
 {
     int i;
 


@@ -1836,10 +1837,7 @@ XEqualRegion(Region r1, Region r2)
     return true;
 }
 
     return true;
 }
 

-bool REGION::
-XPointInRegion(
-    Region pRegion,
-    int x, int y)
+bool REGION::XPointInRegion(Region pRegion, int x, int y)

 {
     int i;
 
 {
     int i;
 


@@ -1855,11 +1853,10 @@ XPointInRegion(
     return false;
 }
 
     return false;
 }
 

-wxRegionContain REGION::
-XRectInRegion(
-    register Region        region,
-    int rx, int ry,
-    unsigned int rwidth, unsigned int rheight)
+wxRegionContain REGION::XRectInRegion(register Region region,
+                                      int rx, int ry,
+                                      unsigned int rwidth,
+                                      unsigned int rheight)

 {
     register BoxPtr pbox;
     register BoxPtr pboxEnd;
 {
     register BoxPtr pbox;
     register BoxPtr pboxEnd;


@@ -1936,4 +1933,3 @@ XRectInRegion(
     return(partIn ? ((ry < prect->y2) ? wxPartRegion : wxInRegion) :
                 wxOutRegion);
 }
     return(partIn ? ((ry < prect->y2) ? wxPartRegion : wxInRegion) :
                 wxOutRegion);
 }

-