758 lines
17 KiB
C++
758 lines
17 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// Name: tests/graphics/clipper.cpp
|
|
// Purpose: wxDCClipper unit tests
|
|
// Author: Artur Wieczorek
|
|
// Created: 2022-12-27
|
|
// Copyright: (c) 2022 wxWidgets development team
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// headers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#include "testprec.h"
|
|
|
|
#include <memory>
|
|
|
|
#include "wx/bitmap.h"
|
|
#include "wx/dcclient.h"
|
|
#include "wx/dcgraph.h"
|
|
#include "wx/dcmemory.h"
|
|
#include "wx/dcsvg.h"
|
|
#include "wx/app.h"
|
|
#include "wx/window.h"
|
|
|
|
#include "testfile.h"
|
|
#include "waitfor.h"
|
|
|
|
static const wxSize s_dcSize(260, 300);
|
|
|
|
static inline wxRect DeviceToLogical(wxDC& dc, const wxRect& r)
|
|
{
|
|
return wxRect(dc.DeviceToLogical(r.GetPosition()), dc.DeviceToLogicalRel(r.GetSize()));
|
|
}
|
|
|
|
static void NoTransform(wxDC& dc)
|
|
{
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r(10, 20, 30, 40);
|
|
wxDCClipper clipper(dc, r);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(r == clipBox);
|
|
}
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipBox == clipBox);
|
|
}
|
|
|
|
static void ExternalTransform(wxDC& dc, bool useTransformMatrix)
|
|
{
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix && !dc.CanUseTransformMatrix() )
|
|
return;
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix )
|
|
{
|
|
wxAffineMatrix2D m;
|
|
m.Translate(40, 75);
|
|
m.Scale(2.0, 3.0);
|
|
dc.SetTransformMatrix(m);
|
|
}
|
|
else
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
{
|
|
dc.SetDeviceOrigin(10, 15);
|
|
dc.SetUserScale(0.5, 1.5);
|
|
dc.SetLogicalScale(4.0, 2.0);
|
|
dc.SetLogicalOrigin(-15, -20);
|
|
}
|
|
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r(10, 20, 30, 40);
|
|
wxDCClipper clipper(dc, r);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(r == clipBox);
|
|
}
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipBox == clipBox);
|
|
}
|
|
|
|
static void InternalTransform(wxDC& dc, bool useTransformMatrix)
|
|
{
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix && !dc.CanUseTransformMatrix() )
|
|
return;
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r(10, 20, 30, 40);
|
|
wxDCClipper clipper(dc, r);
|
|
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix )
|
|
{
|
|
wxAffineMatrix2D m;
|
|
m.Translate(40, 75);
|
|
m.Scale(2.0, 3.0);
|
|
dc.SetTransformMatrix(m);
|
|
}
|
|
else
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
{
|
|
dc.SetDeviceOrigin(10, 15);
|
|
dc.SetUserScale(0.5, 1.5);
|
|
dc.SetLogicalScale(4.0, 2.0);
|
|
dc.SetLogicalOrigin(-15, -20);
|
|
}
|
|
|
|
wxRect clipExpected = DeviceToLogical(dc, r);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(clipExpected == clipBox);
|
|
}
|
|
wxRect initClipExpected = DeviceToLogical(dc, initClipBox);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipExpected == clipBox);
|
|
}
|
|
|
|
static void SpecificClipping(wxDC& dc)
|
|
{
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r(10, 20, 30, 40);
|
|
wxDCClipper clipper(dc, r);
|
|
|
|
const wxRect r1(16, 25, 20, 30);
|
|
dc.SetClippingRegion(r1);
|
|
|
|
wxRect clipExpected = DeviceToLogical(dc, r1);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(clipExpected == clipBox);
|
|
}
|
|
wxRect initClipExpected = DeviceToLogical(dc, initClipBox);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipExpected == clipBox);
|
|
}
|
|
|
|
static void InternalTransformSpecificClipping(wxDC& dc, bool useTransformMatrix)
|
|
{
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix && !dc.CanUseTransformMatrix() )
|
|
return;
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r(10, 20, 30, 40);
|
|
wxDCClipper clipper(dc, r);
|
|
|
|
const wxRect r1(16, 25, 20, 30);
|
|
dc.SetClippingRegion(r1);
|
|
|
|
#if wxUSE_DC_TRANSFORM_MATRIX
|
|
if ( useTransformMatrix )
|
|
{
|
|
wxAffineMatrix2D m;
|
|
m.Translate(40, 75);
|
|
m.Scale(2.0, 3.0);
|
|
dc.SetTransformMatrix(m);
|
|
}
|
|
else
|
|
#endif // wxUSE_DC_TRANSFORM_MATRIX
|
|
{
|
|
dc.SetDeviceOrigin(10, 15);
|
|
dc.SetUserScale(0.5, 1.5);
|
|
dc.SetLogicalScale(4.0, 2.0);
|
|
dc.SetLogicalOrigin(-15, -20);
|
|
}
|
|
|
|
wxRect clipExpected = DeviceToLogical(dc, r1);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(clipExpected == clipBox);
|
|
}
|
|
wxRect initClipExpected = DeviceToLogical(dc, initClipBox);
|
|
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipExpected == clipBox);
|
|
}
|
|
|
|
static void NoTransformEmbeddedClip(wxDC& dc)
|
|
{
|
|
wxRect initClipBox;
|
|
dc.GetClippingBox(initClipBox);
|
|
{
|
|
const wxRect r1(10, 20, 30, 40);
|
|
wxDCClipper clipper1(dc, r1);
|
|
{
|
|
const wxRect r2(15, 25, 20, 30);
|
|
wxDCClipper clipper2(dc, r2);
|
|
|
|
wxRect clipBox2;
|
|
dc.GetClippingBox(clipBox2);
|
|
CHECK(r2 == clipBox2);
|
|
}
|
|
|
|
wxRect clipBox1;
|
|
dc.GetClippingBox(clipBox1);
|
|
CHECK(r1 == clipBox1);
|
|
}
|
|
wxRect clipBox;
|
|
dc.GetClippingBox(clipBox);
|
|
CHECK(initClipBox == clipBox);
|
|
}
|
|
|
|
static void DCAttributes(wxDC& dc)
|
|
{
|
|
// Check if wxDC atrributes left unchanged
|
|
wxFont font = dc.GetFont().Bold().Smaller();
|
|
wxPen pen(*wxYELLOW, 2);
|
|
wxBrush brush = *wxBLUE_BRUSH;
|
|
|
|
wxDCFontChanger fontChanger(dc, font);
|
|
wxDCPenChanger penChanger(dc,pen);
|
|
wxDCBrushChanger brushChanger(dc, brush);
|
|
wxCoord chWidth = dc.GetCharWidth();
|
|
wxCoord chHeight = dc.GetCharHeight();
|
|
wxFontMetrics fm = dc.GetFontMetrics();
|
|
{
|
|
wxDCClipper clipper(dc, 10, 20, 30, 40);
|
|
}
|
|
CHECK(dc.GetFont() == font);
|
|
CHECK(dc.GetPen() == pen);
|
|
CHECK(dc.GetBrush() == brush);
|
|
CHECK(dc.GetCharWidth() == chWidth);
|
|
CHECK(dc.GetCharHeight() == chHeight);
|
|
wxFontMetrics fm2 = dc.GetFontMetrics();
|
|
CHECK(fm2.ascent == fm.ascent);
|
|
CHECK(fm2.averageWidth == fm.averageWidth);
|
|
CHECK(fm2.descent == fm.descent);
|
|
CHECK(fm2.externalLeading == fm.externalLeading);
|
|
CHECK(fm2.height == fm.height);
|
|
CHECK(fm2.internalLeading == fm.internalLeading);
|
|
}
|
|
|
|
TEST_CASE("ClipperTestCase::wxDC", "[clipper][dc]")
|
|
{
|
|
wxBitmap bmp(s_dcSize);
|
|
wxMemoryDC dc(bmp);
|
|
dc.SetBackground(*wxWHITE_BRUSH);
|
|
dc.Clear();
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
|
|
#if wxUSE_GRAPHICS_CONTEXT
|
|
TEST_CASE("ClipperTestCase::wxGCDC", "[clipper][dc][gcdc]")
|
|
{
|
|
#ifdef __WXMSW__
|
|
int depth = GENERATE(24, 32);
|
|
|
|
wxBitmap bmp(s_dcSize, depth);
|
|
#else
|
|
wxBitmap bmp(s_dcSize);
|
|
#endif
|
|
wxMemoryDC mdc(bmp);
|
|
mdc.SetBackground(*wxWHITE_BRUSH);
|
|
mdc.Clear();
|
|
wxGCDC dc(mdc);
|
|
dc.GetGraphicsContext()->SetAntialiasMode(wxANTIALIAS_NONE);
|
|
dc.GetGraphicsContext()->DisableOffset();
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
|
|
#ifdef __WXMSW__
|
|
#if wxUSE_GRAPHICS_GDIPLUS
|
|
TEST_CASE("ClipperTestCase::wxGCDC(GDI+)", "[clipper][dc][gcdc][gdiplus]")
|
|
{
|
|
int depth = GENERATE(24, 32);
|
|
|
|
wxBitmap bmp(s_dcSize, depth);
|
|
wxMemoryDC mdc(bmp);
|
|
mdc.SetBackground(*wxWHITE_BRUSH);
|
|
mdc.Clear();
|
|
wxGraphicsRenderer* rend = wxGraphicsRenderer::GetGDIPlusRenderer();
|
|
REQUIRE(rend);
|
|
wxGraphicsContext* gc = rend->CreateContext(mdc);
|
|
gc->SetAntialiasMode(wxANTIALIAS_NONE);
|
|
gc->DisableOffset();
|
|
wxGCDC dc(gc);
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
#endif // wxUSE_GRAPHICS_GDIPLUS
|
|
|
|
#if wxUSE_GRAPHICS_DIRECT2D
|
|
TEST_CASE("ClipperTestCase::wxGCDC(Direct2D)", "[clipper][dc][gcdc][direct2d]")
|
|
{
|
|
if ( wxIsRunningUnderWine() )
|
|
{
|
|
WARN("Skipping tests known to fail in Wine");
|
|
}
|
|
else
|
|
{
|
|
int depth = GENERATE(24, 32);
|
|
|
|
wxBitmap bmp(s_dcSize, depth);
|
|
wxMemoryDC mdc(bmp);
|
|
mdc.SetBackground(*wxWHITE_BRUSH);
|
|
mdc.Clear();
|
|
wxGraphicsRenderer* rend = wxGraphicsRenderer::GetDirect2DRenderer();
|
|
REQUIRE(rend);
|
|
wxGraphicsContext* gc = rend->CreateContext(mdc);
|
|
gc->SetAntialiasMode(wxANTIALIAS_NONE);
|
|
gc->DisableOffset();
|
|
wxGCDC dc(gc);
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
}
|
|
#endif // wxUSE_GRAPHICS_DIRECT2D
|
|
#endif // __WXMSW__
|
|
|
|
#if wxUSE_CAIRO
|
|
TEST_CASE("ClipperTestCase::wxGCDC(Cairo)", "[clipper][dc][gcdc][cairo]")
|
|
{
|
|
#ifdef __WXMSW__
|
|
int depth = GENERATE(24, 32);
|
|
|
|
wxBitmap bmp(s_dcSize, depth);
|
|
#else
|
|
wxBitmap bmp(s_dcSize);
|
|
#endif
|
|
wxMemoryDC mdc(bmp);
|
|
mdc.SetBackground(*wxWHITE_BRUSH);
|
|
mdc.Clear();
|
|
wxGraphicsRenderer* rend = wxGraphicsRenderer::GetCairoRenderer();
|
|
REQUIRE(rend);
|
|
wxGraphicsContext* gc = rend->CreateContext(mdc);
|
|
gc->SetAntialiasMode(wxANTIALIAS_NONE);
|
|
gc->DisableOffset();
|
|
wxGCDC dc(gc);
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
#endif // wxUSE_CAIRO
|
|
|
|
#endif // wxUSE_GRAPHICS_CONTEXT
|
|
|
|
#if wxUSE_SVG
|
|
TEST_CASE("ClipperTestCase::wxSVGFileDC", "[clipper][dc][svgdc]")
|
|
{
|
|
TestFile tf;
|
|
wxSVGFileDC dc(tf.GetName(), s_dcSize.x, s_dcSize.y);
|
|
dc.SetBackground(*wxWHITE_BRUSH);
|
|
dc.Clear();
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
}
|
|
#endif // wxUSE_SVG
|
|
|
|
TEST_CASE("ClipperTestCase::wxPaintDC", "[clipper][dc][paintdc]")
|
|
{
|
|
// Ensure window is shown and large enough for testing
|
|
wxTheApp->GetTopWindow()->Raise();
|
|
REQUIRE(wxTheApp->GetTopWindow()->IsShown());
|
|
wxSize winSize = wxTheApp->GetTopWindow()->GetSize();
|
|
winSize.x = wxMax(winSize.x, s_dcSize.x + 50);
|
|
winSize.y = wxMax(winSize.y, s_dcSize.y + 50);
|
|
wxTheApp->GetTopWindow()->SetSize(winSize);
|
|
#if defined(__WXGTK__)
|
|
// Under wxGTK we need to have two children (at least) because if there
|
|
// is one child its paint area is set to fill the whole parent frame.
|
|
std::unique_ptr<wxWindow> w0(new wxWindow(wxTheApp->GetTopWindow(), wxID_ANY));
|
|
#endif // wxGTK
|
|
std::unique_ptr<wxWindow> win(new wxWindow(wxTheApp->GetTopWindow(), wxID_ANY, wxPoint(0, 0)));
|
|
win->SetClientSize(s_dcSize);
|
|
|
|
// Wait for the first paint event to be sure
|
|
// that window really has its final size.
|
|
wxWindow* testWin = win.get();
|
|
{
|
|
WaitForPaint waitForPaint(testWin);
|
|
testWin->Show();
|
|
waitForPaint.YieldUntilPainted();
|
|
}
|
|
|
|
bool paintExecuted = false;
|
|
testWin->Bind(wxEVT_PAINT, [=, &paintExecuted](wxPaintEvent&)
|
|
{
|
|
wxPaintDC dc(testWin);
|
|
REQUIRE(dc.GetSize() == s_dcSize);
|
|
dc.SetBackground(*wxWHITE_BRUSH);
|
|
dc.Clear();
|
|
|
|
SECTION("NoTransform")
|
|
{
|
|
NoTransform(dc);
|
|
}
|
|
|
|
SECTION("ExternalTransform 1")
|
|
{
|
|
ExternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("ExternalTransform 2")
|
|
{
|
|
ExternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("InternalTransform 1")
|
|
{
|
|
InternalTransform(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransform 2")
|
|
{
|
|
InternalTransform(dc, true);
|
|
}
|
|
|
|
SECTION("SpecificClipping")
|
|
{
|
|
SpecificClipping(dc);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 1")
|
|
{
|
|
InternalTransformSpecificClipping(dc, false);
|
|
}
|
|
|
|
SECTION("InternalTransformSpecificClipping 2")
|
|
{
|
|
InternalTransformSpecificClipping(dc, true);
|
|
}
|
|
|
|
SECTION("NoTransformEmbeddedClip")
|
|
{
|
|
NoTransformEmbeddedClip(dc);
|
|
}
|
|
|
|
SECTION("DCAttributes")
|
|
{
|
|
DCAttributes(dc);
|
|
}
|
|
|
|
paintExecuted = true;
|
|
});
|
|
|
|
testWin->Refresh();
|
|
testWin->Update();
|
|
// Wait for update to be done
|
|
YieldForAWhile();
|
|
|
|
CHECK(paintExecuted == true);
|
|
}
|