more event loop work recovered from some botch in december

simpledisplay.d

@@ -4014,6 +4014,10 @@ struct EventLoop {
 	}
 
 	static void quitApplication() {
+		version(use_arsd_core) {
+			import arsd.core;
+			ICoreEventLoop.exitApplication();
+		}
 		EventLoop.get().exit();
 	}
 
@@ -4062,10 +4066,15 @@ struct EventLoop {
 		return impl.run(whileCondition);
 	}
 
-	/// Exits the event loop
+	/// Exits the event loop, but allows you to reenter it again later (in contrast with quitApplication, which tries to terminate the program)
 	void exit() {
 		assert(impl !is null);
 		impl.notExited = false;
+
+		version(use_arsd_core) {
+			import arsd.core;
+			ICoreEventLoop.exitApplication();
+		}
 	}
 
 	version(linux)
@@ -4314,6 +4323,24 @@ struct EventLoopImpl {
 	version(Windows)
 	ref auto customEventH() { return SimpleWindow.customEventH; }
 
+	version(X11) {
+		bool doXPending() {
+			bool done = false;
+
+			this.mtLock();
+			scope(exit) this.mtUnlock();
+			//{ import core.stdc.stdio; printf("*** queued: %d\n", XEventsQueued(this.display, QueueMode.QueuedAlready)); }
+			while(!done && XPending(display)) {
+				done = doXNextEvent(this.display);
+			}
+
+			return done;
+		}
+		void doXNextEventVoid() {
+			doXPending();
+		}
+	}
+
 	version(with_eventloop) {
 		int loopHelper(bool delegate() whileCondition) {
 			// FIXME: whileCondition
@@ -4330,7 +4357,77 @@ struct EventLoopImpl {
 			insideXEventLoop = true;
 			scope(exit) insideXEventLoop = false;
 
-			version(linux) {
+			version(use_arsd_core) {
+				import arsd.core;
+				auto el = getThisThreadEventLoop(EventLoopType.Ui);
+
+				static bool loopInitialized = false;
+				if(!loopInitialized) {
+					el.addDelegateOnLoopIteration(&doXNextEventVoid, 0);
+					el.addDelegateOnLoopIteration(&SimpleWindow.processAllCustomEvents, 0);
+
+					if(customSignalFD != -1)
+					el.addCallbackOnFdReadable(customSignalFD, new CallbackHelper(() {
+						version(linux) {
+							import core.sys.linux.sys.signalfd;
+							import core.sys.posix.unistd : read;
+							signalfd_siginfo info;
+							read(customSignalFD, &info, info.sizeof);
+
+							auto sig = info.ssi_signo;
+
+							if(EventLoop.get.signalHandler !is null) {
+								EventLoop.get.signalHandler()(sig);
+							} else {
+								EventLoop.get.exit();
+							}
+						}
+					}));
+
+					if(display.fd != -1)
+					el.addCallbackOnFdReadable(display.fd, new CallbackHelper(() {
+						this.mtLock();
+						scope(exit) this.mtUnlock();
+						while(!done && XPending(display)) {
+							done = doXNextEvent(this.display);
+						}
+					}));
+
+					if(pulseFd != -1)
+					el.addCallbackOnFdReadable(pulseFd, new CallbackHelper(() {
+						long expirationCount;
+						// if we go over the count, I ignore it because i don't want the pulse to go off more often and eat tons of cpu time...
+
+						handlePulse();
+
+						// read just to clear the buffer so poll doesn't trigger again
+						// BTW I read AFTER the pulse because if the pulse handler takes
+						// a lot of time to execute, we don't want the app to get stuck
+						// in a loop of timer hits without a chance to do anything else
+						//
+						// IOW handlePulse happens at most once per pulse interval.
+						unix.read(pulseFd, &expirationCount, expirationCount.sizeof);
+					}));
+
+					if(customEventFDRead != -1)
+					el.addCallbackOnFdReadable(customEventFDRead, new CallbackHelper(() {
+						// we have some custom events; process 'em
+						import core.sys.posix.unistd : read;
+						ulong n;
+						read(customEventFDRead, &n, n.sizeof); // reset counter value to zero again
+						//{ import core.stdc.stdio; printf("custom event! count=%u\n", eventQueueUsed); }
+						//SimpleWindow.processAllCustomEvents();
+					}));
+
+					// FIXME: posix fds
+					// FIXME up?
+
+
+					loopInitialized = true;
+				}
+
+				el.run(() => !whileCondition());
+			} else version(linux) {
 				while(!done && (whileCondition is null || whileCondition() == true) && notExited) {
 					bool forceXPending = false;
 					auto wto = SimpleWindow.eventAllQueueTimeoutMSecs();
@@ -4449,12 +4546,7 @@ struct EventLoopImpl {
 					// i.e. we HAVE to repeatedly call `XPending()` even if libX fd wasn't signalled!
 					xpending:
 					if (!done && forceXPending) {
-						this.mtLock();
+						done = doXPending();
-						scope(exit) this.mtUnlock();
-						//{ import core.stdc.stdio; printf("*** queued: %d\n", XEventsQueued(this.display, QueueMode.QueuedAlready)); }
-						while(!done && XPending(display)) {
-							done = doXNextEvent(this.display);
-						}
 					}
 				}
 			} else {
@@ -4541,52 +4633,65 @@ struct EventLoopImpl {
 		}
 
 		version(Windows) {
-			int ret = -1;
-			MSG message;
-			while(ret != 0 && (whileCondition is null || whileCondition() == true) && notExited) {
-				eventLoopRound++;
-				auto wto = SimpleWindow.eventAllQueueTimeoutMSecs();
-				auto waitResult = MsgWaitForMultipleObjectsEx(
-					cast(int) handles.length, handles.ptr,
-					(wto == 0 ? INFINITE : wto), /* timeout */
-					0x04FF, /* QS_ALLINPUT */
-					0x0002 /* MWMO_ALERTABLE */ | 0x0004 /* MWMO_INPUTAVAILABLE */);
 
-				SimpleWindow.processAllCustomEvents(); // anyway
+			version(use_arsd_core) {
-				enum WAIT_OBJECT_0 = 0;
+				import arsd.core;
-				if(waitResult >= WAIT_OBJECT_0 && waitResult < handles.length + WAIT_OBJECT_0) {
+				auto el = getThisThreadEventLoop(EventLoopType.Ui);
-					auto h = handles[waitResult - WAIT_OBJECT_0];
+				static bool loopInitialized = false;
-					if(auto e = h in WindowsHandleReader.mapping) {
+				if(!loopInitialized) {
-						(*e).ready();
+					el.addDelegateOnLoopIteration(&SimpleWindow.processAllCustomEvents, 0);
-					}
+					el.addDelegateOnLoopIteration(function() { eventLoopRound++; }, 0);
-				} else if(waitResult == handles.length + WAIT_OBJECT_0) {
+					loopInitialized = true;
-					// message ready
+				}
-					int count;
+				el.run(() => !whileCondition());
-					while(PeekMessage(&message, null, 0, 0, PM_NOREMOVE)) { // need to peek since sometimes MsgWaitForMultipleObjectsEx returns even though GetMessage can block. tbh i don't fully understand it but the docs say it is foreground activation
+			} else {
-						ret = GetMessage(&message, null, 0, 0);
+				int ret = -1;
-						if(ret == -1)
+				MSG message;
-							throw new WindowsApiException("GetMessage", GetLastError());
+				while(ret != 0 && (whileCondition is null || whileCondition() == true) && notExited) {
-						TranslateMessage(&message);
+					eventLoopRound++;
-						DispatchMessage(&message);
+					auto wto = SimpleWindow.eventAllQueueTimeoutMSecs();
+					auto waitResult = MsgWaitForMultipleObjectsEx(
+						cast(int) handles.length, handles.ptr,
+						(wto == 0 ? INFINITE : wto), /* timeout */
+						0x04FF, /* QS_ALLINPUT */
+						0x0002 /* MWMO_ALERTABLE */ | 0x0004 /* MWMO_INPUTAVAILABLE */);
 
-						count++;
+					SimpleWindow.processAllCustomEvents(); // anyway
-						if(count > 10)
+					enum WAIT_OBJECT_0 = 0;
-							break; // take the opportunity to catch up on other events
+					if(waitResult >= WAIT_OBJECT_0 && waitResult < handles.length + WAIT_OBJECT_0) {
-
+						auto h = handles[waitResult - WAIT_OBJECT_0];
-						if(ret == 0) { // WM_QUIT
+						if(auto e = h in WindowsHandleReader.mapping) {
-							EventLoop.quitApplication();
+							(*e).ready();
-							break;
 						}
+					} else if(waitResult == handles.length + WAIT_OBJECT_0) {
+						// message ready
+						int count;
+						while(PeekMessage(&message, null, 0, 0, PM_NOREMOVE)) { // need to peek since sometimes MsgWaitForMultipleObjectsEx returns even though GetMessage can block. tbh i don't fully understand it but the docs say it is foreground activation
+							ret = GetMessage(&message, null, 0, 0);
+							if(ret == -1)
+								throw new WindowsApiException("GetMessage", GetLastError());
+							TranslateMessage(&message);
+							DispatchMessage(&message);
+
+							count++;
+							if(count > 10)
+								break; // take the opportunity to catch up on other events
+
+							if(ret == 0) { // WM_QUIT
+								EventLoop.quitApplication();
+								break;
+							}
+						}
+					} else if(waitResult == 0x000000C0L /* WAIT_IO_COMPLETION */) {
+						SleepEx(0, true); // I call this to give it a chance to do stuff like async io
+					} else if(waitResult == 258L /* WAIT_TIMEOUT */) {
+						// timeout, should never happen since we aren't using it
+					} else if(waitResult == 0xFFFFFFFF) {
+							// failed
+							throw new WindowsApiException("MsgWaitForMultipleObjectsEx", GetLastError());
+					} else {
+						// idk....
 					}
-				} else if(waitResult == 0x000000C0L /* WAIT_IO_COMPLETION */) {
-					SleepEx(0, true); // I call this to give it a chance to do stuff like async io
-				} else if(waitResult == 258L /* WAIT_TIMEOUT */) {
-					// timeout, should never happen since we aren't using it
-				} else if(waitResult == 0xFFFFFFFF) {
-						// failed
-						throw new WindowsApiException("MsgWaitForMultipleObjectsEx", GetLastError());
-				} else {
-					// idk....
 				}
 			}
 
@@ -5618,6 +5723,11 @@ class Timer {
 			version(with_eventloop) {
 				import arsd.eventloop;
 				addFileEventListeners(fd, &trigger, null, null);
+			} else version(use_arsd_core) {
+				import arsd.core;
+				auto el = getThisThreadEventLoop(EventLoopType.Ui);
+
+				unregisterToken = el.addCallbackOnFdReadable(fd, new CallbackHelper(&trigger));
 			} else {
 				prepareEventLoop();
 
@@ -5629,6 +5739,13 @@ class Timer {
 		} else featureNotImplemented();
 	}
 
+	version(use_arsd_core) {
+		version(Windows) {} else {
+			import arsd.core;
+			ICoreEventLoop.UnregisterToken unregisterToken;
+		}
+	}
+
 	private int intervalInMilliseconds;
 
 	// just cuz I sometimes call it this.
@@ -5636,6 +5753,11 @@ class Timer {
 
 	/// Stop and destroy the timer object.
 	void destroy() {
+		version(use_arsd_core) {
+			version(Windows) {} else
+				unregisterToken.unregister();
+		}
+
 		version(Windows) {
 			staticDestroy(handle);
 			handle = null;
@@ -5675,7 +5797,17 @@ class Timer {
 		}
 	}
 
+	version(use_arsd_core) { version(Windows) {} else
+	static void unregister(arsd.core.ICoreEventLoop.UnregisterToken urt) {
+		urt.unregister();
+	}
+	}
+
 	~this() {
+		version(use_arsd_core) { version(Windows) {} else
+			cleanupQueue.queue!unregister(unregisterToken);
+		}
+
 		version(Windows) { if(handle)
 			cleanupQueue.queue!staticDestroy(handle);
 		} else version(linux) { if(fd != -1)
@@ -5788,20 +5920,31 @@ class WindowsHandleReader {
 		enable();
 	}
 
+	version(use_arsd_core)
+		ICoreEventLoop.UnregisterToken unregisterToken;
+
 	///
 	void enable() {
-		auto el = EventLoop.get().impl;
+		version(use_arsd_core) {
-		el.handles ~= handle;
+			unregisterToken = getThisThreadEventLoop(EventLoopType.Ui).addCallbackOnHandleReady(handle, new CallbackHelper(&ready));
+		} else {
+			auto el = EventLoop.get().impl;
+			el.handles ~= handle;
+		}
 	}
 
 	///
 	void disable() {
-		auto el = EventLoop.get().impl;
+		version(use_arsd_core) {
-		for(int i = 0; i < el.handles.length; i++) {
+			unregisterToken.unregister();
-			if(el.handles[i] is handle) {
+		} else {
-				el.handles[i] = el.handles[$-1];
+			auto el = EventLoop.get().impl;
-				el.handles = el.handles[0 .. $-1];
+			for(int i = 0; i < el.handles.length; i++) {
-				return;
+				if(el.handles[i] is handle) {
+					el.handles[i] = el.handles[$-1];
+					el.handles = el.handles[0 .. $-1];
+					return;
+				}
 			}
 		}
 	}
@@ -5857,14 +6000,24 @@ class PosixFdReader {
 	bool captureReads;
 	bool captureWrites;
 
+	version(use_arsd_core) {
+		import arsd.core;
+		ICoreEventLoop.UnregisterToken unregisterToken;
+	}
+
 	version(with_eventloop) {} else
 	///
 	void enable() @system {
-		prepareEventLoop();
-
 		enabled = true;
 
-		version(linux) {
+		version(use_arsd_core) {
+			unregisterToken = getThisThreadEventLoop(EventLoopType.Ui).addCallbackOnFdReadable(fd, new CallbackHelper(
+				() { onReady(fd, true, false); }
+			));
+			// FIXME: what if it is writeable?
+
+		} else version(linux) {
+			prepareEventLoop();
 			static import ep = core.sys.linux.epoll;
 			ep.epoll_event ev = void;
 			ev.events = (captureReads ? ep.EPOLLIN : 0) | (captureWrites ? ep.EPOLLOUT : 0);
@@ -5879,11 +6032,13 @@ class PosixFdReader {
 	version(with_eventloop) {} else
 	///
 	void disable() @system {
-		prepareEventLoop();
-
 		enabled = false;
 
+		version(use_arsd_core) {
+			unregisterToken.unregister();
+		} else
 		version(linux) {
+			prepareEventLoop();
 			static import ep = core.sys.linux.epoll;
 			ep.epoll_event ev = void;
 			ev.events = (captureReads ? ep.EPOLLIN : 0) | (captureWrites ? ep.EPOLLOUT : 0);