Unify event loop functions as puglUpdate()

The previous separation between polling and dispatching was a lie, especially
on MacOS where it is impossible to only poll for events without dispatching
anything.  Providing such an API is misleading, and problematic in various
other ways.

So, merge them into a single puglUpdate() function which can do the right thing
on all platforms.  This also adds the behaviour of actually processing all
events in the given time interval, which is almost always what clients actually
want to do when using a positive timeout (naively doing this before caused
terrible input lag).

1 files changed, 124 insertions, 0 deletions

diff --git a/test/test_update.c b/test/test_update.c
new file mode 100644
index 0000000..bbda94a
--- /dev/null
+++ b/test/test_update.c
@@ -0,0 +1,124 @@
+/*
+  Copyright 2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/*
+  Tests that redisplays posted in the event handler are dispatched at the end
+  of the same event loop iteration.
+*/
+
+#undef NDEBUG
+
+#include "test_utils.h"
+
+#include "pugl/pugl.h"
+#include "pugl/pugl_stub.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __APPLE__
+static const double timeout = 1 / 60.0;
+#else
+static const double timeout = -1.0;
+#endif
+
+typedef enum {
+	START,
+	EXPOSED1,
+	UPDATED,
+	EXPOSED2,
+} State;
+
+typedef struct {
+	PuglTestOptions opts;
+	PuglWorld*      world;
+	PuglView*       view;
+	State           state;
+} PuglTest;
+
+static PuglStatus
+onEvent(PuglView* view, const PuglEvent* event)
+{
+	PuglTest* test = (PuglTest*)puglGetHandle(view);
+
+	if (test->opts.verbose) {
+		printEvent(event, "Event: ", true);
+	}
+
+	switch (event->type) {
+	case PUGL_EXPOSE:
+		switch (test->state) {
+		case START:
+			test->state = EXPOSED1;
+			break;
+		case UPDATED:
+			test->state = EXPOSED2;
+			break;
+		default:
+			break;
+		}
+		break;
+
+	case PUGL_UPDATE:
+		if (test->state == EXPOSED1) {
+			puglPostRedisplay(view);
+			test->state = UPDATED;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return PUGL_SUCCESS;
+}
+
+int
+main(int argc, char** argv)
+{
+	PuglTest app = {puglParseTestOptions(&argc, &argv),
+	                puglNewWorld(PUGL_PROGRAM, 0),
+	                NULL,
+	                START};
+
+	// Set up view
+	app.view = puglNewView(app.world);
+	puglSetClassName(app.world, "Pugl Test");
+	puglSetBackend(app.view, puglStubBackend());
+	puglSetHandle(app.view, &app);
+	puglSetEventFunc(app.view, onEvent);
+
+	// Create and show window
+	assert(!puglCreateWindow(app.view, "Pugl Test"));
+	assert(!puglShowWindow(app.view));
+
+	// Tick until an expose happens
+	while (app.state <= EXPOSED1) {
+		assert(!puglUpdate(app.world, timeout));
+		assert(app.state != UPDATED);
+	}
+
+	// Tick once and ensure the update and the expose it posted both happened
+	assert(!puglUpdate(app.world, 0.0));
+	assert(app.state == EXPOSED2);
+
+	// Tear down
+	puglFreeView(app.view);
+	puglFreeWorld(app.world);
+
+	return 0;
+}