Merge remote-tracking branch 'origin/ISSUE-26' into ISSUE-21

Author: JasonZink

win32/N3888_RefImpl/drawing.h

@@ -877,6 +877,7 @@ namespace std {
 
 			int format_stride_for_width(format format, int width);
 			surface make_surface(surface::native_handle_type nh);
+			surface make_surface(format format, int width, int height);
 			path _Make_path(path::native_handle_type nh);
 		}
 	}

win32/N3888_RefImpl/entrypoint-win32.cpp

@@ -8,6 +8,7 @@
 
 #include <memory>
 #include <functional>
+#include <atomic>
 #include <wrl.h>
 #include "throw_helpers.h"
 #include "drawing.h"
@@ -24,40 +25,70 @@ using namespace std::experimental::drawing;
 
 #define MAX_LOADSTRING 100
 
+class ref_counted_bool {
+	::std::atomic<int> m_refCount;
+public:
+	ref_counted_bool() : m_refCount(0) {}
+	ref_counted_bool& operator=(bool value) {
+		if (value) {
+			m_refCount++;
+		}
+		else {
+			auto count = m_refCount.load(memory_order_acquire);
+			if (--count < 0) {
+				count = 0;
+			}
+			m_refCount.store(count, memory_order_release);
+		}
+		return *this;
+	}
+	operator bool() {
+		return m_refCount.load() != 0;
+	}
+};
+
 // Global Variables:
 HINSTANCE hInst;								// current instance
 TCHAR szTitle[MAX_LOADSTRING];					// The title bar text
 TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name
 unique_ptr<surface> g_psurface;
+RECT g_previousClientRect;
+ref_counted_bool g_doNotPaint;
 
 // Everything in the Draw function should be portable C++ code.
 void Draw(surface& surface) {
 	// Create a context that will draw to our surface.
 	auto context = drawing::context(surface);
 
 	// The is a demonstration of how a raster_source_pattern works. We create one that is 100px x 100px
-	auto pattern = raster_source_pattern(nullptr, content::color_alpha, 100, 100);
-	pattern.set_acquire(
-		[pattern](void*, experimental::drawing::surface& target, const rectangle_int& extents) -> experimental::drawing::surface
-	{
-		auto result = experimental::drawing::image_surface(target, format::rgb24, extents.width - extents.x, extents.height - extents.y);
-		vector<unsigned char> data;
-		const auto dataSize = result.get_stride() * result.get_height();
-		data.resize(dataSize);
-		for (auto i = 0; i < dataSize; i += 4) {
-			data[i + 0] = 255ui8;
-			data[i + 1] = 0ui8;
-			data[i + 2] = 0ui8;
-			data[i + 3] = 0ui8;
-		}
-		result.set_data(data);
-		return result;
-	},
-		nullptr
-		);
-	pattern.set_extend(extend::repeat);
-	context.set_source(pattern);
+	//auto pattern = raster_source_pattern(nullptr, content::color_alpha, 100, 100);
+	//pattern.set_acquire(
+	//	[pattern](void*, experimental::drawing::surface& target, const rectangle_int& extents) -> experimental::drawing::surface
+	//{
+	//	auto result = experimental::drawing::image_surface(target, format::rgb24, extents.width - extents.x, extents.height - extents.y);
+	//	vector<unsigned char> data;
+	//	const auto dataSize = result.get_stride() * result.get_height();
+	//	data.resize(dataSize);
+	//	for (auto i = 0; i < dataSize; i += 4) {
+	//		data[i + 0] = 255ui8;
+	//		data[i + 1] = 0ui8;
+	//		data[i + 2] = 0ui8;
+	//		data[i + 3] = 0ui8;
+	//	}
+	//	result.set_data(data);
+	//	return result;
+	//},
+	//	nullptr
+	//	);
+	//pattern.set_extend(extend::repeat);
+	//context.set_source(pattern);
+	//context.paint();
+
+	context.save();
+	auto scp = solid_color_pattern(0.0, 0.0, 1.0);
+	context.set_source(scp);
 	context.paint();
+	context.restore();
 
 	context.save();
 	const int width = 100;
@@ -98,6 +129,43 @@ void Draw(surface& surface) {
 	imageSurfaceFromData.finish();
 	context.restore();
 
+	context.save();
+	auto surfaceForContext2 = image_surface(format::argb32, 100, 100);
+	auto context2 = drawing::context(surfaceForContext2);
+	context2.set_source_rgba(0.5, 0.5, 0.5, 0.5);
+	context2.set_compositing_operator(compositing_operator::clear);
+	context2.paint_with_alpha(0.0);
+	context2.set_source_rgba(0.5, 0.5, 0.5, 0.5);
+	context2.set_compositing_operator(compositing_operator::add);
+	context2.paint();
+	surfaceForContext2.flush();
+	context.set_source_surface(surfaceForContext2, 600.0, 400.0);
+	context.move_to(600.0, 400.0);
+	context.rel_line_to(100.0, 0.0);
+	context.rel_line_to(0.0, 100.0);
+	context.rel_line_to(-100.0, 0.0);
+	context.close_path();
+	context.fill();
+	context.set_source_surface(surfaceForContext2, 650.0, 400.0);
+	context.move_to(650.0, 400.0);
+	context.rel_line_to(100.0, 0.0);
+	context.rel_line_to(0.0, 100.0);
+	context.rel_line_to(-100.0, 0.0);
+	context.close_path();
+	context.fill();
+	context.restore();
+
+	context.save();
+	auto subsurface = drawing::surface(surface, 10.5, 11.0, 50.0, 50.0);
+	auto subcontext = drawing::context(subsurface);
+	subcontext.set_source_rgb(0.0, 0.0, 0.0);
+	subcontext.move_to(2.0, 2.0);
+	subcontext.rel_line_to(48.0, 0.0);
+	subcontext.set_line_width(3.0);
+	subcontext.set_line_cap(line_cap::butt);
+	subcontext.stroke();
+	context.restore();
+
 	context.save();
 	matrix m;
 	m.init_translate(300.0, 400.0);
@@ -129,8 +197,6 @@ void Draw(surface& surface) {
 	context.select_font_face("Segoe UI", font_slant::normal, font_weight::normal);
 	context.set_font_size(30.0);
 	context.show_text("Hello C++!");
-
-	//surface.finish();
 }
 
 void OnPaint(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
@@ -140,23 +206,51 @@ void OnPaint(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 
 	PAINTSTRUCT ps;
 	HDC hdc;
+	RECT updateRect{ };
+	auto getUpdateRectResult = GetUpdateRect(hWnd, &updateRect, FALSE);
+
+	// There's a bug somewhere (possibly cairo?) where if you run this code without the check to make sure that
+	// updateRect.left and .top are both 0, it crashes and does so in the cairo DLL such that it's immune to
+	// being caught. Specifically in a Win32/Debug config it throws well inside cairo on the ctxt.paint() call
+	// on an illegal memory access (actually in pixman-sse2.c in a call to "void save_128_aligned(__m128i*, __m128i);").
+	if (getUpdateRectResult != FALSE && updateRect.left == 0 && updateRect.top == 0) {
+		hdc = BeginPaint(hWnd, &ps);
+
+		RECT clientRect;
+		if (!GetClientRect(hWnd, &clientRect)) {
+			throw_get_last_error<logic_error>("Failed GetClientRect call.");
+		}
+		auto width = clientRect.right - clientRect.left;
+		auto height = clientRect.bottom - clientRect.top;
+		auto previousWidth = g_previousClientRect.right - g_previousClientRect.left;
+		auto previousHeight = g_previousClientRect.bottom - g_previousClientRect.top;
+
+		// To enable screenshot saving, we are using a global unique_ptr surface. I did not rewrite the boilerplate
+		// Win32 code so that it'd be a class, hence the globals.
+		if ((g_psurface == nullptr) || (width != previousWidth) || (height != previousHeight)) {
+			g_psurface = unique_ptr<surface>(new surface(move(make_surface(format::argb32, width, height))));
+			g_previousClientRect = clientRect;
+		}
 
-	hdc = BeginPaint(hWnd, &ps);
-
-	// To enable screenshot saving, we are using a global unique_ptr surface. I did not rewrite the boilerplate
-	// Win32 code so that it'd be a class, hence the globals. Note that this would not work without using CS_OWNDC
-	// when registering the window class since we could get a different HDC each time without that flag.
-	if (g_psurface == nullptr) {
-		g_psurface = unique_ptr<surface>(new surface(move(make_surface(cairo_win32_surface_create(hdc)))));
-	}
-
-	// Draw to the off-screen buffer.
-	Draw(*g_psurface);
+		// Draw to the off-screen buffer.
+		Draw(*g_psurface);
 
-	// Flush to ensure that it is drawn to the window.
-	g_psurface->flush();
+		// Flush to ensure that it is drawn to the window.
+		g_psurface->flush();
 
-	EndPaint(hWnd, &ps);
+		auto surface = make_surface(cairo_win32_surface_create(hdc));
+		auto ctxt = context(surface);
+		ctxt.set_source_surface(*g_psurface, 0.0, 0.0);
+		ctxt.paint();
+		surface.flush();
+		EndPaint(hWnd, &ps);
+	}
+	else {
+		if (getUpdateRectResult != FALSE) {
+			hdc = BeginPaint(hWnd, &ps);
+			EndPaint(hWnd, &ps);
+		}
+	}
 }
 
 int WINAPI wWinMain(
@@ -167,6 +261,7 @@ int WINAPI wWinMain(
 	) {
 	UNREFERENCED_PARAMETER(hPrevInstance);
 	UNREFERENCED_PARAMETER(lpCmdLine);
+	g_previousClientRect = { }; // Zero out previous client rect.
 	throw_if_failed_hresult<runtime_error>(
 		CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED), "Failed call to CoInitializeEx."
 		);
@@ -195,7 +290,38 @@ int WINAPI wWinMain(
 	while (msg.message != WM_QUIT) {
 		if (!PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) {
 			// No message so redraw the window.
-			RedrawWindow(hWnd, nullptr, nullptr, RDW_INVALIDATE | RDW_UPDATENOW);
+			if (g_psurface != nullptr && !g_doNotPaint) {
+				RECT clientRect;
+				if (!GetClientRect(hWnd, &clientRect)) {
+					throw_get_last_error<logic_error>("Failed GetClientRect call.");
+				}
+				auto width = clientRect.right - clientRect.left;
+				auto height = clientRect.bottom - clientRect.top;
+				auto previousWidth = g_previousClientRect.right - g_previousClientRect.left;
+				auto previousHeight = g_previousClientRect.bottom - g_previousClientRect.top;
+
+				// To enable screenshot saving, we are using a global unique_ptr surface. I did not rewrite the boilerplate
+				// Win32 code so that it'd be a class, hence the globals.
+				if ((width != previousWidth) || (height != previousHeight)) {
+					g_psurface = unique_ptr<surface>(new surface(move(make_surface(format::argb32, width, height))));
+					g_previousClientRect = clientRect;
+				}
+
+				// Draw to the off-screen buffer.
+				Draw(*g_psurface);
+
+				// Flush to ensure that it is drawn to the window.
+				g_psurface->flush();
+				auto hdc = GetDC(hWnd);
+				{
+					auto surface = make_surface(cairo_win32_surface_create(hdc));
+					auto ctxt = context(surface);
+					ctxt.set_source_surface(*g_psurface, 0.0, 0.0);
+					ctxt.paint();
+					surface.flush();
+				}
+				ReleaseDC(hWnd, hdc);
+			}
 		}
 		else {
 			if (msg.message != WM_QUIT) {
@@ -220,7 +346,7 @@ ATOM MyRegisterClass(HINSTANCE hInstance) {
 
 	wcex.cbSize = sizeof(WNDCLASSEX);
 
-	wcex.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+	wcex.style = 0;
 	wcex.lpfnWndProc = WndProc;
 	wcex.cbClsExtra = 0;
 	wcex.cbWndExtra = 0;
@@ -373,6 +499,14 @@ void ShowSaveAsPNGDialog() {
 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 	int wmId, wmEvent;
 
+#if defined(DEBUG_WNDPROC)
+	wstringstream str;
+	str << L"Message: 0x" << hex << uppercase << message << nouppercase
+		<< L". WPARAM: 0x" << hex << uppercase << static_cast<UINT>(wParam) << nouppercase
+		<< L". LPARAM: 0x" << hex << uppercase << static_cast<UINT>(lParam) << endl;
+	OutputDebugStringW(str.str().c_str());
+#endif
+
 	switch (message) {
 	case WM_COMMAND:
 		wmId = LOWORD(wParam);
@@ -397,8 +531,16 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			return DefWindowProc(hWnd, message, wParam, lParam);
 		}
 		break;
+	case WM_ENTERSIZEMOVE:
+		g_doNotPaint = true; // Don't paint while resizing to avoid flicker.
+		return DefWindowProc(hWnd, message, wParam, lParam);
+	case WM_EXITSIZEMOVE:
+		g_doNotPaint = false;
+		return DefWindowProc(hWnd, message, wParam, lParam);
 	case WM_PAINT:
-		OnPaint(hWnd, message, wParam, lParam);
+		if (!g_doNotPaint) {
+			OnPaint(hWnd, message, wParam, lParam);
+		}
 		break;
 	case WM_DESTROY:
 		PostQuitMessage(0);

win32/N3888_RefImpl/standalone_functions.cpp

@@ -30,6 +30,10 @@ namespace std {
 				return surface(nh);
 			}
 
+			surface make_surface(format fmt, int width, int height) {
+				return image_surface(fmt, width, height);
+			}
+
 			int format_stride_for_width(format format, int width) {
 				return cairo_format_stride_for_width(_Format_to_cairo_format_t(format), width);
 			}