/////////////////////////////////////////////////////////////////////////////
-// Name: region.cpp
+// Name: src/mgl/region.cpp
// Purpose: Region handling for wxWidgets/MGL
// Author: Vaclav Slavik
// RCS-ID: $Id$
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "region.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
#include "wx/region.h"
-#include "wx/gdicmn.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/gdicmn.h"
+ #include "wx/module.h"
+#endif
+
#include "wx/thread.h"
-#include "wx/module.h"
#include <mgraph.hpp>
m_region = data.m_region;
}
- ~wxRegionRefData() {}
+ virtual ~wxRegionRefData() {}
MGLRegion m_region;
};
// wxRegion
//-----------------------------------------------------------------------------
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
}
wxRegion::wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
-{
+{
m_refData = new wxRegionRefData;
MGLRect rect(x, y, x + w, y + h);
M_REGION = rect;
M_REGION = region;
}
+wxRegion::wxRegion(size_t n, const wxPoint *points, int WXUNUSED(fillStyle))
+{
+ m_refData = new wxRegionRefData;
+ point_t *pts = new point_t[n];
+
+ for (size_t i = 0; i < n; i++)
+ {
+ pts[i].x = points[i].x;
+ pts[i].y = points[i].y;
+ }
+
+ region_t* rgn = MGL_rgnPolygon(n, pts, 1, 0, 0);
+
+ M_REGION = rgn;
+
+ delete [] pts;
+}
+
wxRegion::~wxRegion()
{
// m_refData unrefed in ~wxObject
// Information on region
//-----------------------------------------------------------------------------
+bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
+{
+ wxFAIL_MSG( wxT("not implemented") );
+
+ return false;
+}
+
// Outer bounds of region
-void wxRegion::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const
+bool wxRegion::DoGetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const
{
- if (m_refData)
+ if (m_refData)
{
rect_t rect;
rect = M_REGION.getBounds();
y = rect.top;
w = rect.right - rect.left;
h = rect.bottom - rect.top;
- }
- else
+
+ return true;
+ }
+ else
{
x = y = w = h = 0;
+ return false;
}
}
-wxRect wxRegion::GetBox() const
-{
- wxCoord x, y, w, h;
- GetBox(x, y, w, h);
- return wxRect(x, y, w, h);
-}
-
// Is region empty?
-bool wxRegion::Empty() const
+bool wxRegion::IsEmpty() const
{
- if (!m_refData) return TRUE;
- return M_REGION.isEmpty();
+ if (!m_refData)
+ return true;
+
+ return (bool)(M_REGION.isEmpty());
}
//-----------------------------------------------------------------------------
// Modifications
//-----------------------------------------------------------------------------
-bool wxRegion::Offset(wxCoord x, wxCoord y)
+bool wxRegion::DoOffset(wxCoord x, wxCoord y)
{
AllocExclusive();
M_REGION.offset(x, y);
- return TRUE;
+ return true;
}
// Union rectangle or region with this.
-bool wxRegion::Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+bool wxRegion::DoUnionWithRect(const wxRect& r)
{
AllocExclusive();
- M_REGION += MGLRect(x, y, x + width, y + height);
- return TRUE;
+ M_REGION += MGLRect(r.x, r.y, r.GetRight() + 1, r.GetHeight() + 1);
+ return true;
}
-bool wxRegion::Union(const wxRegion& region)
+bool wxRegion::DoUnionWithRegion(const wxRegion& region)
{
AllocExclusive();
M_REGION += M_REGION_OF(region);
- return TRUE;
+ return true;
}
-// Intersect rectangle or region with this.
-bool wxRegion::Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
-{
- AllocExclusive();
- M_REGION &= MGLRect(x, y, x + width, y + height);
- return TRUE;
-}
-
-bool wxRegion::Intersect(const wxRegion& region)
+bool wxRegion::DoIntersect(const wxRegion& region)
{
AllocExclusive();
M_REGION &= M_REGION_OF(region);
- return TRUE;
-}
-
-// Subtract rectangle or region from this:
-// Combines the parts of 'this' that are not part of the second region.
-bool wxRegion::Subtract(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
-{
- AllocExclusive();
- M_REGION -= MGLRect(x, y, x + width, y + height);
- return TRUE;
+ return true;
}
-bool wxRegion::Subtract(const wxRegion& region)
+bool wxRegion::DoSubtract(const wxRegion& region)
{
AllocExclusive();
M_REGION -= M_REGION_OF(region);
- return TRUE;
+ return true;
}
-// XOR: the union of two combined regions except for any overlapping areas.
-bool wxRegion::Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
-{
- AllocExclusive();
- MGLRect rect(x, y, x + width, y + height);
- MGLRegion rg1 = M_REGION + rect,
- rg2 = M_REGION & rect;
- M_REGION = rg1 - rg2;
- return TRUE;
-}
-
-bool wxRegion::Xor(const wxRegion& region)
+bool wxRegion::DoXor(const wxRegion& region)
{
AllocExclusive();
MGLRegion rg1 = M_REGION + M_REGION_OF(region),
rg2 = M_REGION & M_REGION_OF(region);
M_REGION = rg1 - rg2;
- return TRUE;
+ return true;
}
//-----------------------------------------------------------------------------
// Does the region contain the point (x,y)?
-wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y) const
+wxRegionContain wxRegion::DoContainsPoint(wxCoord x, wxCoord y) const
{
if (!m_refData)
return wxOutRegion;
return wxOutRegion;
}
-// Does the region contain the point pt?
-wxRegionContain wxRegion::Contains(const wxPoint& pt) const
-{
- return Contains(pt.x, pt.y);
-}
-
// Does the region contain the rectangle (x, y, w, h)?
-wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const
+wxRegionContain wxRegion::DoContainsRect(const wxRect& r) const
{
if (!m_refData)
return wxOutRegion;
- MGLRect rect(x, y, x + w, y + h);
+ MGLRect rect(r.x, r.y, r.GetRight() + 1, r.GetBottom() + 1);
MGLRegion rg;
-
+
// 1) is the rectangle entirely covered by the region?
rg = MGLRegion(rect) - M_REGION;
- if (rg.isEmpty()) return wxInRegion;
-
+ if (rg.isEmpty())
+ return wxInRegion;
+
// 2) is the rectangle completely outside the region?
rg = M_REGION & rect; // intersection
- if (rg.isEmpty()) return wxOutRegion;
+ if (rg.isEmpty())
+ return wxOutRegion;
// 3) neither case happened => it is partially covered:
return wxPartRegion;
}
-// Does the region contain the rectangle rect
-wxRegionContain wxRegion::Contains(const wxRect& rect) const
-{
- return Contains(rect.x, rect.y, rect.width, rect.height);
-}
-
-
///////////////////////////////////////////////////////////////////////////////
// wxRegionIterator //
///////////////////////////////////////////////////////////////////////////////
virtual bool OnInit()
{
gs_mutexIterator = new wxMutex();
- return TRUE;
+ return true;
}
virtual void OnExit()
{
*/
wxRegionIterator::wxRegionIterator() : m_currentNode(NULL)
{
- m_rects.DeleteContents(TRUE);
+ m_rects.DeleteContents(true);
}
wxRegionIterator::~wxRegionIterator()
*/
wxRegionIterator::wxRegionIterator(const wxRegion& region)
{
- m_rects.DeleteContents(TRUE);
+ m_rects.DeleteContents(true);
Reset(region);
}
/*
* Reset iterator for a new /e region.
*/
-
+
static wxRegionRectList *gs_rectList;
static void MGLAPI wxMGL_region_callback(const rect_t *r)
{
- gs_rectList->Append(new wxRect(r->left, r->top,
+ gs_rectList->Append(new wxRect(r->left, r->top,
r->right - r->left, r->bottom - r->top));
}
-
+
void wxRegionIterator::Reset(const wxRegion& region)
{
m_currentNode = NULL;
if (!region.Empty())
{
#if wxUSE_THREADS
- wxMutexLocker(*gs_mutexIterator);
+ wxMutexLocker lock(*gs_mutexIterator);
#endif
gs_rectList = &m_rects;
M_REGION_OF(region).traverse(wxMGL_region_callback);
projects / wxWidgets.git / blobdiff