more midi stuff

dub.json

@@ -196,6 +196,18 @@
 			"dflags": ["-mv=arsd.midi=midi.d"],
 			"sourceFiles": ["midi.d"]
 		},
+		{
+			"name": "midiplayer",
+			"description": "turn-key midi player library",
+			"importPaths": ["."],
+			"targetType": "library",
+			"dflags": ["-mv=arsd.midiplayer=midiplayer.d"],
+			"sourceFiles": ["midiplayer.d"],
+			"dependencies": {
+				"arsd-official:simpleaudio":"*",
+				"arsd-official:midi":"*"
+			}
+		},
 		{
 			"name": "nukedopl3",
 			"description": "nukedopl3 emulator port, required by simpleaudio's playEmulatedOpl3Midi functio",

midi.d

@@ -12,6 +12,14 @@
 */
 module arsd.midi;
 
+
+/+
+	So the midi ticks are defined in terms of per quarter note so that's good stuff.
+
+	If you're reading live though you have milliseconds, and probably want to round them
+	off a little to fit the beat.
++/
+
 import core.time;
 
 version(NewMidiDemo)
@@ -138,31 +146,175 @@ class MidiFile {
 		Note that you do not need to handle any meta events, it keeps the
 		tempo internally, but you can look at it if you like.
 	+/
-	PlayStream playbackStream() {
+	const(PlayStreamEvent)[] playbackStream() {
-		return PlayStream(this);
+		PlayStreamEvent[] stream;
+		size_t size;
+		foreach(track; tracks)
+			size += track.events.length;
+		stream.reserve(size);
+
+		Duration position;
+
+		static struct NoteOnInfo {
+			PlayStreamEvent* event;
+			int turnedOnTicks;
+			Duration turnedOnPosition;
+		}
+		NoteOnInfo[] noteOnInfo = new NoteOnInfo[](128 * 16);
+		scope(exit) noteOnInfo = null;
+
+		static struct LastNoteInfo {
+			PlayStreamEvent*[6] event; // in case there's a chord
+			int eventCount;
+			int turnedOnTicks;
+		}
+		LastNoteInfo[/*16*/] lastNoteInfo = new LastNoteInfo[](16); // it doesn't allow the static array cuz of @safe and i don't wanna deal with that so just doing this, nbd alloc anyway
+
+		void recordOff(scope NoteOnInfo* noi, int midiClockPosition) {
+			noi.event.noteOnDuration = position - noi.turnedOnPosition;
+
+			noi.event = null;
+		}
+
+		// FIXME: what about rests?
+		foreach(item; flattenedTrackStream) {
+			position += item.wait;
+
+			stream ~= item;
+
+			if(item.event.event == MIDI_EVENT_NOTE_ON) {
+				if(item.event.data2 == 0)
+					goto off;
+
+				auto ptr = &stream[$-1];
+
+				auto noi = &noteOnInfo[(item.event.channel & 0x0f) * 128 + (item.event.data1 & 0x7f)];
+
+				if(noi.event) {
+					recordOff(noi, item.midiClockPosition);
+				}
+
+				noi.event = ptr;
+				noi.turnedOnTicks = item.midiClockPosition;
+				noi.turnedOnPosition = position;
+
+				auto lni = &lastNoteInfo[(item.event.channel & 0x0f)];
+				if(lni.eventCount) {
+					if(item.midiClockPosition == lni.turnedOnTicks) {
+						if(lni.eventCount == lni.event.length)
+							goto maxedOut;
+						lni.event[lni.eventCount++] = ptr;
+					} else {
+						maxedOut:
+						foreach(ref e; lni.event[0 .. lni.eventCount])
+							e.midiTicksToNextNoteOnChannel = item.midiClockPosition - lni.turnedOnTicks;
+
+						goto frist;
+					}
+				} else {
+					frist:
+					lni.event[0] = ptr;
+					lni.eventCount = 1;
+					lni.turnedOnTicks = item.midiClockPosition;
+				}
+
+			} else if(item.event.event == MIDI_EVENT_NOTE_OFF) {
+				off:
+				auto noi = &noteOnInfo[(item.event.channel & 0x0f) * 128 + (item.event.data1 & 0x7f)];
+
+				if(noi.event) {
+					recordOff(noi, item.midiClockPosition);
+				}
+			}
+		}
+
+		return stream;
+	}
+
+	/++
+		Returns a forward range for playback or analysis that flattens the midi
+		tracks into a single stream. Each item is a command, which
+		is like the midi event but with some more annotations and control methods.
+
+		Modifying this MidiFile object or any of its children during iteration
+		may cause trouble.
+
+		Note that you do not need to handle any meta events, it keeps the
+		tempo internally, but you can look at it if you like.
+	+/
+	FlattenedTrackStream flattenedTrackStream() {
+		return FlattenedTrackStream(this);
 	}
 }
 
-struct PlayStream {
+static struct PlayStreamEvent {
-	static struct Event {
+	/// This is how long you wait until triggering this event.
-		/// This is how long you wait until triggering this event.
+	/// Note it may be zero.
-		/// Note it may be zero.
+	Duration wait;
-		Duration wait;
 
-		/// And this is the event.
+	/// And this is the midi event message.
-		MidiEvent event;
+	MidiEvent event;
 
-		string toString() {
+	string toString() const {
-			return event.toString();
+		return event.toString();
-		}
-
-		/// informational
-		MidiFile file;
-		/// ditto
-		MidiTrack track;
 	}
 
-	PlayStream save() {
+	/// informational. May be null if the stream didn't come from a file or tracks.
+	MidiFile file;
+	/// ditto
+	MidiTrack track;
+
+	/++
+		Gives the position ot the global midi clock for this event. The `event.deltaTime`
+		is in units of the midi clock, but the actual event has the clock per-track whereas
+		this value is global, meaning it might not be the sum of event.deltaTime to this point.
+		(It should add up if you only sum ones with the same [track] though.
+
+		The midi clock is used in conjunction with the [MidiFile.timing] and current tempo
+		state to determine a real time wait value, which you can find in the [wait] member.
+
+		This position is probably less useful than the running sum of [wait]s, but is provided
+		just in case it is useful to you.
+	+/
+	int midiClockPosition;
+
+	/++
+		The duration between this non-zero velocity note on and its associated note off.
+
+		Will be zero if this isn't actually a note on, the input stream was not seekable (e.g.
+		a real time recording), or if a note off was not found ahead in the stream.
+
+		It is basically how long the pianist held down the key.
+
+		Be aware that that the note on to note off is not necessarily associated with the
+		note you'd see on sheet music. It is more about the time the sound actually rings,
+		but it may not exactly be that either due to the time it takes for the note to
+		fade out.
+	+/
+	Duration noteOnDuration;
+	/++
+		This is the count of midi clock ticks after this non-zero velocity note on event (if
+		it is not one of those, this value will be zero) and the next note that will be sounded
+		on its same channel.
+
+		While rests may throw this off, this number is the most help in this struct for determining
+		the note length you'd put on sheet music. Divide it by [MidiFile.timing] to get the number
+		of midi quarter notes, which is directly correlated to the musical beat.
+
+		Will be zero if this isn't actually a note on, the input stream was not seekable (e.g.
+		a real time recording where the next note hasn't been struck yet), or if a note off was
+		not found ahead in the stream.
+	+/
+	int midiTicksToNextNoteOnChannel;
+
+	// when recording and working in milliseconds we prolly want to round off to the nearest 64th note, or even less fine grained at user command todeal with bad musicians (i.e. me) being off beat
+}
+
+static immutable(PlayStreamEvent)[] longWait = [{wait: 1.weeks, event: {status: 0xff, data1: 0x01, meta: null}}];
+
+struct FlattenedTrackStream {
+
+	FlattenedTrackStream save() {
 		auto copy = this;
 		copy.trackPositions = this.trackPositions.dup;
 		return copy;
@@ -178,12 +330,14 @@ struct PlayStream {
 		}
 
 		this.currentTrack = -1;
-		this.tempo = 500000;
+		this.tempo = 500000; // microseconds per quarter note
 		popFront();
 	}
 
 	//@nogc:
 
+	int midiClock;
+
 	void popFront() {
 		done = true;
 		for(auto c = currentTrack + 1; c < trackPositions.length; c++) {
@@ -197,7 +351,7 @@ struct PlayStream {
 					currentTrack += 1;
 				}
 
-				pending = Event(0.seconds, f, file, tp.track);
+				pending = PlayStreamEvent(0.seconds, f, file, tp.track, midiClock);
 				processPending();
 				done = false;
 				return;
@@ -232,9 +386,11 @@ struct PlayStream {
 		// if high bit set... idk it is different.
 		//
 		// then the temp is microseconds per quarter note.
-		auto time = (minWait * tempo / file.timing).usecs;
 
-		pending = Event(time, trackPositions[minWaitTrack].remaining[0], file, trackPositions[minWaitTrack].track);
+		auto time = (cast(long) minWait * tempo / file.timing).usecs;
+		midiClock += minWait;
+
+		pending = PlayStreamEvent(time, trackPositions[minWaitTrack].remaining[0], file, trackPositions[minWaitTrack].track, midiClock);
 		processPending();
 		trackPositions[minWaitTrack].remaining = trackPositions[minWaitTrack].remaining[1 .. $];
 		trackPositions[minWaitTrack].clock = 0;
@@ -262,18 +418,19 @@ struct PlayStream {
 	}
 
 	@property
-	Event front() {
+	PlayStreamEvent front() {
 		return pending;
 	}
 
 	private uint tempo;
-	private Event pending;
+	private PlayStreamEvent pending;
 	private bool done;
 
 	@property
 	bool empty() {
 		return done;
 	}
+
 }
 
 class MidiTrack {
@@ -303,6 +460,10 @@ class MidiTrack {
 
 		while(buf.bytes.length) {
 			MidiEvent newEvent = MidiEvent.fromBuffer(buf, runningStatus);
+
+			if(newEvent.isMeta && newEvent.data1 == MetaEvent.Name)
+				name_ = cast(string) newEvent.meta.idup;
+
 			if(newEvent.status == 0xff && newEvent.data1 == MetaEvent.EndOfTrack) {
 				break;
 			}
@@ -311,7 +472,28 @@ class MidiTrack {
 		//assert(begin - trackLength == buf.bytes.length);
 	}
 
+	/++
+		All the midi events found in the track.
+	+/
 	MidiEvent[] events;
+	/++
+		The name of the track, as found from metadata at load time.
+
+		This may change to scan events to see updates without the cache in the future.
+	+/
+	@property string name() {
+		return name_;
+	}
+
+	private string name_;
+
+	/++
+		This field is not used or stored in a midi file; it is just
+		a place to store some state in your player.
+
+		I use it to keep flags like if the track is currently enabled.
+	+/
+	int customPlayerInfo;
 
 	override string toString() const {
 		string s;
@@ -383,6 +565,39 @@ struct MidiEvent {
 	/// ditto
 	static MidiEvent CuePoint(string t) { return MidiEvent(0, 0xff, MetaEvent.CuePoint, 0, cast(const(ubyte)[]) t); }
 
+	/++
+		Conveneince factories for normal events. These just put your given values into the event as raw data so you're responsible to know what they do.
+
+		History:
+			Added January 2, 2022 (dub v10.5)
+	+/
+	static MidiEvent NoteOn(int channel, int note, int velocity) { return MidiEvent(0, (MIDI_EVENT_NOTE_ON << 4) | (channel & 0x0f), note & 0x7f, velocity & 0x7f); }
+	/// ditto
+	static MidiEvent NoteOff(int channel, int note, int velocity) { return MidiEvent(0, (MIDI_EVENT_NOTE_OFF << 4) | (channel & 0x0f), note & 0x7f, velocity & 0x7f); }
+
+	/+
+	// FIXME: this is actually a relatively complicated one i should fix, it combines bits... 8192 == 0.
+	// This is a bit of a magical function, it takes a signed bend between 0 and 81
+	static MidiEvent PitchBend(int channel, int bend) {
+		return MidiEvent(0, (MIDI_EVENT_PITCH_BEND << 4) | (channel & 0x0f), bend & 0x7f, bend & 0x7f);
+	}
+	+/
+	// this overload ok, it is what the thing actually tells. coarse == 64 means we're at neutral.
+	/// ditto
+	static MidiEvent PitchBend(int channel, int fine, int coarse) { return MidiEvent(0, (MIDI_EVENT_PITCH_BEND << 4) | (channel & 0x0f), fine & 0x7f, coarse & 0x7f); }
+
+	/// ditto
+	static MidiEvent NoteAftertouch(int channel, int note, int velocity) { return MidiEvent(0, (MIDI_EVENT_NOTE_AFTERTOUCH << 4) | (channel & 0x0f), note & 0x7f, velocity & 0x7f); }
+	// FIXME the different controllers do have standard IDs we could look up in an enum... and many of them have coarse/fine things you can send as two messages.
+	/// ditto
+	static MidiEvent Controller(int channel, int controller, int value) { return MidiEvent(0, (MIDI_EVENT_CONTROLLER << 4) | (channel & 0x0f), controller & 0x7f, value & 0x7f); }
+
+	// the two byte ones
+	/// ditto
+	static MidiEvent ProgramChange(int channel, int program) { return MidiEvent(0, (MIDI_EVENT_PROGRAM_CHANGE << 4) | (channel & 0x0f), program & 0x7f); }
+	/// ditto
+	static MidiEvent ChannelAftertouch(int channel, int param) { return MidiEvent(0, (MIDI_EVENT_CHANNEL_AFTERTOUCH << 4) | (channel & 0x0f), param & 0x7f); }
+
 	///
 	bool isMeta() const {
 		return status == 0xff;
@@ -435,6 +650,7 @@ struct MidiEvent {
 		s ~= " ";
 		s ~= toh(data1);
 		s ~= " ";
+
 		if(isMeta) {
 			switch(data1) {
 				case MetaEvent.Text:
@@ -488,6 +704,20 @@ struct MidiEvent {
 			}
 		} else {
 			s ~= toh(data2);
+
+			s ~= " ";
+			s ~= tos(channel);
+			s ~= " ";
+			switch(event) {
+				case MIDI_EVENT_NOTE_OFF: s ~= "NOTE_OFF"; break;
+				case MIDI_EVENT_NOTE_ON: s ~=  data2 ? "NOTE_ON" : "NOTE_ON_ZERO"; break;
+				case MIDI_EVENT_NOTE_AFTERTOUCH: s ~= "NOTE_AFTERTOUCH"; break;
+				case MIDI_EVENT_CONTROLLER: s ~= "CONTROLLER"; break;
+				case MIDI_EVENT_PROGRAM_CHANGE: s ~= "PROGRAM_CHANGE"; break;
+				case MIDI_EVENT_CHANNEL_AFTERTOUCH: s ~= "CHANNEL_AFTERTOUCH"; break;
+				case MIDI_EVENT_PITCH_BEND: s ~= "PITCH_BEND"; break;
+				default:
+			}
 		}
 
 		return s;

midiplayer.d

@@ -0,0 +1,534 @@
+/++
+	An add-on to [arsd.simpleaudio] that provides a MidiOutputThread
+	that can play files from [arsd.midi].
+
+	History:
+		Added January 1, 2022 (dub v10.5). Not fully stablized but this
+		release does almost everything I want right now, so I don't
+		expect to change it much.
++/
+module arsd.midiplayer;
+
+// FIXME:  I want a record stream somewhere too, perhaps to a MidiFile and then a callback so you can inject events here as well.
+
+import arsd.simpleaudio;
+import arsd.midi;
+
+/++
+	[arsd.simpleaudio] provides a MidiEvent enum, but the one we're more
+	interested here is the midi file format event, which is found in [arsd.midi].
+
+	This alias disambiguates that we're interested in the file format one, not the enum.
++/
+alias MidiEvent = arsd.midi.MidiEvent;
+
+import core.thread;
+import core.atomic;
+
+/++
+	This is the main feature of this module - a struct representing an automatic midi thread.
+
+	It wraps [MidiOutputThreadImplementation] for convenient refcounting and raii messaging.
+
+	You create this, optionally set your callbacks to filter/process events as they happen
+	and deal with end of stream, then pass it a stream and events. The methods will give you
+	control while the thread manages the timing and dispatching of events.
++/
+struct MidiOutputThread {
+	@disable this();
+
+	static if(__VERSION__ < 2098)
+		mixin(q{ @disable new(size_t); }); // gdc9 requires the arg fyi, but i mix it in because dmd deprecates before semantic so it can't be versioned out ugh
+	else
+		@disable new(); // but new dmd is strict about not allowing it
+
+	/// it refcounts the impl.
+	this(this) {
+		if(impl)
+			atomicOp!"+="(impl.refcount, 1);
+	}
+	/// when the refcount reaches zero, it exits the impl thread and waits for it to join.
+	~this() {
+		if(impl)
+		if(atomicOp!"-="(impl.refcount, 1) == 0) {
+			impl.exit();
+			(cast() impl).join();
+		}
+		impl = null;
+	}
+
+	/++
+		Creates a midi output thread using the given device, and starts it.
+	+/
+	this(string device, bool startSuspended = false) {
+		auto thing = new MidiOutputThreadImplementation(device, startSuspended);
+		impl = cast(shared) thing;
+		thing.isDaemon = true;
+		thing.start();
+
+		// FIXME: check if successfully initialized
+	}
+
+	// FIXME: prolly opDispatch wrap it instead
+	auto getImpl() { return impl; }
+	/++
+		You can call any `shared` member of [MidiOutputThreadImplementation] through this
+		struct.
+	+/
+	alias getImpl this;
+
+	private shared(MidiOutputThreadImplementation) impl;
+}
+
+class MidiOutputThreadImplementation : Thread {
+	private int refcount = 1;
+
+	/++
+		Set this if you want to filter or otherwise respond to events.
+
+		Return true to continue processing the event, return false if you want
+		to skip it.
+
+		The midi thread calls this function, so beware of cross-thread issues
+		and make sure you spend as little time as possible in the callback to
+		avoid throwing off time.
+	+/
+	void setCallback(bool delegate(const PlayStreamEvent) callback) shared {
+		auto us = cast() this;
+		synchronized(this)
+			us.callback = callback;
+	}
+
+	/++
+		Set this to customize what happens when a stream finishes.
+
+		You can call [suspend], [loadStream], or [exit] to override
+		the default behavior of looping the song. Or, return without
+		calling anything to let it automatically start back over.
+	+/
+	void setStreamFinishedCallback(void delegate() callback) shared {
+		auto us = cast() this;
+		synchronized(this)
+			us.streamFinishedCallback = callback;
+	}
+
+	/++
+		Injects a midi event to the stream. It will be triggered as
+		soon as possible and will NOT trigger you callback.
+	+/
+	void injectEvent(ubyte a, ubyte b, ubyte c) shared {
+		auto us = cast() this;
+		uint injected = a | (b << 8) | (c << 16);
+
+		synchronized(this) {
+			us.injectedEvents[(us.injectedEnd++) & 0x0f] = injected;
+		}
+
+		us.event.set();
+	}
+
+	/// ditto
+	void injectEvent(MidiEvent event) shared {
+		injectEvent(event.status, event.data1, event.data2);
+	}
+
+	/++
+		Stops playback and closes the midi device, but keeps the thread waiting
+		for an [unsuspend] call.
+
+		When you do unsuspend, any stream will be restarted from the beginning.
+	+/
+	void suspend() shared {
+		auto us = cast() this;
+		us.suspended = true;
+		us.event.set();
+	}
+
+	/// ditto
+	void unsuspend() shared {
+		auto us = cast() this;
+		synchronized(this) {
+			if(!this.filePending) {
+				pendingStream = stream;
+				filePending = true;
+			}
+		}
+		us.suspended = false;
+		us.event.set();
+	}
+
+	/++
+		Pauses the midi playback. Will send a silence notes controller message to all channels, but otherwise leaves everything in place for a future call to [unpause].
+	+/
+	void pause() shared {
+		auto us = cast() this;
+		us.paused = true;
+		us.event.set();
+	}
+
+	/// ditto
+	void unpause() shared {
+		auto us = cast() this;
+		us.paused = false;
+		us.event.set();
+	}
+
+	/// ditto
+	void togglePause() shared {
+		if(paused)
+			unpause();
+		else
+			pause();
+	}
+
+	/++
+		Stops the current playback stream. Will call the callback you set in [setCallback].
+
+		Note: if you didn't set a callback, `stop` will end the stream, but then it will
+		automatically loop back to the beginning!
+	+/
+	void stop() shared {
+		auto us = cast() this;
+		us.stopRequested = true;
+		us.event.set();
+	}
+
+	/++
+		Exits the thread. The object is not usable again after calling this.
+	+/
+	void exit() shared {
+		auto us = cast() this;
+		us.exiting = true;
+		us.event.set();
+	}
+
+	/++
+		Changes the speed of the playback clock to the given multiplier. So
+		passing `2.0` will play at double real time. Calling it again will still
+		play a double real time; the multiplier is always relative to real time
+		and will not stack.
+	+/
+	void setSpeed(float multiplier) shared {
+		auto us = cast() this;
+		auto s = cast(int) (1000 * multiplier);
+		if(s <= 0)
+			s = 1;
+		synchronized(this) {
+			us.speed = s;
+		}
+		us.event.set();
+	}
+
+	/++
+		If you want to use only injected events as a play stream,
+		you might use arsd.midi.longWait here and just inject
+		things as they come.
+	+/
+	void loadStream(const(PlayStreamEvent)[] pendingStream) shared {
+		auto us = cast() this;
+		synchronized(this) {
+			us.pendingStream = pendingStream;
+			us.filePending = true;
+		}
+		us.event.set();
+	}
+
+	/++
+		Instructs the player to start playing - unsuspend if suspended,
+		unpause if paused. If it is already playing, it will do nothing.
+	+/
+	void play() shared {
+		auto us = cast() this;
+		if(us.paused)
+			unpause();
+		if(us.suspended)
+			unsuspend();
+		us.event.set();
+	}
+
+	import core.sync.event;
+
+	private Event event;
+	private bool delegate(const PlayStreamEvent) callback;
+	private void delegate() streamFinishedCallback;
+	private bool paused;
+
+	private uint[16] injectedEvents;
+	private int injectedStart;
+	private int injectedEnd;
+
+	private string device;
+	private bool filePending;
+	private const(PlayStreamEvent)[] stream;
+	private const(PlayStreamEvent)[] pendingStream;
+	private const(PlayStreamEvent)[] loopStream;
+	private bool suspended;
+	private int speed = 1000;
+	private bool exiting;
+	private bool stopRequested;
+
+	/+
+		Do not modify the stream from outside!
+	+/
+
+	/++
+		If you use the device string "DUMMY", it will still give you
+		a timed thread with callbacks, but will not actually write to
+		any midi device. You might use this if you want, for example,
+		to display notes visually but not play them so a student can
+		follow along with the computer.
+	+/
+	this(string device = "default", bool startSuspended = false) {
+		this.device = device;
+		super(&run);
+		event.initialize(false, false);
+		if(startSuspended)
+			suspended = true;
+	}
+
+	private void run() {
+
+		version(linux) {
+			// this thread has no business intercepting signals from the main thread,
+			// so gonna block a couple of them
+			import core.sys.posix.signal;
+			sigset_t sigset;
+			auto err = sigemptyset(&sigset);
+			assert(!err);
+
+			err = sigaddset(&sigset, SIGINT); assert(!err);
+			err = sigaddset(&sigset, SIGCHLD); assert(!err);
+
+			err = sigprocmask(SIG_BLOCK, &sigset, null);
+			assert(!err);
+		}
+
+		typeof(this.streamFinishedCallback) streamFinishedCallback;
+
+		suspend:
+
+		if(exiting)
+			return;
+
+		while(suspended) {
+			event.wait();
+			if(exiting)
+				return;
+		}
+
+		MidiOutput midiOut = MidiOutput(device);
+		bool justConstructed = true;
+		scope(exit) {
+			// the midi pages say not to send reset upon power up
+			// so im trying not to send it too much. idk if it actually
+			// matters tho.
+			if(!justConstructed)
+				midiOut.reset();
+		}
+
+		typeof(this.callback) callback;
+
+		while(!filePending) {
+			event.wait();
+			if(exiting)
+				return;
+			if(suspended)
+				goto suspend;
+		}
+
+		newFile:
+
+		if(exiting)
+			return;
+
+		synchronized(this) {
+			stream = pendingStream;
+			filePending = false;
+			pendingStream = null;
+		}
+
+		restart_song:
+
+		if(exiting)
+			return;
+
+		if(!justConstructed) {
+			midiOut.reset();
+		}
+		justConstructed = false;
+
+		MMClock mmclock;
+		Duration position;
+
+		loopStream = stream;//.save();
+		mmclock.restart();
+
+		foreach(item; stream) {
+			if(exiting)
+				return;
+
+			while(paused) {
+				pause:
+				midiOut.silenceAllNotes();
+				mmclock.pause();
+				event.wait();
+				if(exiting)
+					return;
+				if(stopRequested)
+					break;
+				if(suspended)
+					goto suspend;
+				if(filePending)
+					goto newFile;
+			}
+
+			mmclock.unpause();
+
+			synchronized(this) {
+				mmclock.speed = this.speed;
+
+				callback = this.callback;
+				playInjectedEvents(&midiOut);
+			}
+
+			position += item.wait;
+
+			another_event:
+			// FIXME: seeking
+			// FIXME: push and pop song...
+			// FIXME: note duration down to 64th notes would be like 30 ms at 120 bpm time....
+			auto diff = mmclock.timeUntil(position);
+			if(diff > 0.msecs) {
+				if(!event.wait(diff)) {
+					if(exiting)
+						return;
+					if(stopRequested)
+						break;
+					if(suspended)
+						goto suspend;
+					if(filePending)
+						goto newFile;
+					if(paused)
+						goto pause;
+					goto another_event;
+				}
+			}
+
+			if(callback is null || callback(item)) {
+				if(item.event.isMeta)
+					continue;
+
+				midiOut.writeMidiMessage(item.event.status, item.event.data1, item.event.data2);
+			}
+		}
+
+		stopRequested = false;
+		stream = loopStream;
+		if(stream.length == 0) {
+			// there's nothing to loop... exiting or suspending is the only real choice
+			// this really should never happen but the idea is to avoid being stuck in
+			// a busy loop.
+			suspended = true;
+		}
+
+		synchronized(this)
+			streamFinishedCallback = this.streamFinishedCallback;
+
+		if(streamFinishedCallback) {
+			streamFinishedCallback();
+		} else {
+			// default behavior?
+			// maybe prepare loop and suspend...
+			if(!filePending) {
+				suspended = true;
+			}
+		}
+
+		finalLoop:
+		if(exiting)
+			return;
+		if(suspended)
+			goto suspend;
+		if(filePending)
+			goto newFile;
+		goto restart_song;
+	}
+
+	// Assumes this holds the `this` synchronized lock!!!
+	private void playInjectedEvents(MidiOutput* midiOut) {
+		while((injectedStart & 0x0f) != (injectedEnd & 0x0f)) {
+			auto a = injectedEvents[injectedStart & 0x0f];
+			injectedStart++;
+			midiOut.writeMidiMessage(a & 0xff, (a >> 8) & 0xff, (a >> 16) & 0xff);
+		}
+	}
+}
+
+version(midiplayer_demo)
+void main(string[] args) {
+	import std.stdio;
+	import std.file;
+	auto f = new MidiFile;
+	f.loadFromBytes(cast(ubyte[]) read(args[1]));
+
+	auto t = MidiOutputThread("hw:4");
+	t.setCallback(delegate(const PlayStreamEvent item) {
+
+		if(item.event.channel == 0 && item.midiTicksToNextNoteOnChannel)
+			writeln(item.midiTicksToNextNoteOnChannel * 64 / f.timing);
+		return item.event.channel == 0;
+	});
+
+	t.loadStream(f.playbackStream);
+
+	readln();
+
+	/+
+	t.loadStream(longWait);
+
+	string s = readln();
+	while(s.length) {
+		t.injectEvent(MidiEvent.NoteOn(0, s[0], 127));
+		s = readln()[0 .. $-1];
+	}
+
+	return;
+	+/
+
+
+	/+
+	t.loadStream(f.playbackStream);
+
+	//f = new MidiFile;
+	//f.loadFromBytes(cast(ubyte[]) read(args[2]));
+
+	//t.loadStream(f.playbackStream);
+
+
+	t.setStreamFinishedCallback(delegate() {
+		writeln("finished!");
+		t.pause();
+		//t.exit();
+	});
+
+	writeln("1");
+	readln();
+	writeln("2");
+	//t.pause();
+
+	t.setSpeed(12.0);
+
+	while(readln().length) {
+		t.injectEvent(MIDI_EVENT_NOTE_ON << 4, 55, 0);
+	}
+
+	//t.injectEvent(MIDI_EVENT_PROGRAM_CHANGE << 4, 55, 0);
+	//t.injectEvent(1 | (MIDI_EVENT_PROGRAM_CHANGE << 4), 55, 0);
+
+	writeln("3");
+	readln();
+	t.setSpeed(0.5);
+	writeln("4");
+	t.unpause();
+	+/
+}

minigui.d

@@ -1584,6 +1584,8 @@ class Widget : ReflectableProperties {
 		This is available primarily to be overridden. For example, [MainWindow] overrides it to redirect its children into a central widget.
 	+/
 	protected void addChild(Widget w, int position = int.max) {
+		assert(w._parent !is this, "Child cannot be added twice to the same parent");
+		assert(w !is this, "Child cannot be its own parent!");
 		w._parent = this;
 		if(position == int.max || position == children.length) {
 			_children ~= w;
@@ -1696,14 +1698,15 @@ class Widget : ReflectableProperties {
 
 		version(win32_widgets) {
 			HANDLE b, p;
-			if(c.a == 0) {
+			if(c.a == 0 && parent is parentWindow) {
+				// I don't remember why I had this really...
 				b = SelectObject(painter.impl.hdc, GetSysColorBrush(COLOR_3DFACE));
 				p = SelectObject(painter.impl.hdc, GetStockObject(NULL_PEN));
 			}
 		}
 		painter.drawRectangle(Point(0, 0), width, height);
 		version(win32_widgets) {
-			if(c.a == 0) {
+			if(c.a == 0 && parent is parentWindow) {
 				SelectObject(painter.impl.hdc, p);
 				SelectObject(painter.impl.hdc, b);
 			}
@@ -1720,15 +1723,15 @@ class Widget : ReflectableProperties {
 			parent = parent.parent;
 		}
 
-		auto painter = parentWindow.win.draw();
+		auto painter = parentWindow.win.draw(true);
 		painter.originX = x;
 		painter.originY = y;
 		painter.setClipRectangle(Point(0, 0), width, height);
 		return WidgetPainter(painter, this);
 	}
 
-	/// This can be overridden by scroll things. It is responsible for actually calling [paint]. Do not override unless you've studied minigui.d's source code.
+	/// This can be overridden by scroll things. It is responsible for actually calling [paint]. Do not override unless you've studied minigui.d's source code. There are no stability guarantees if you do override this; it can (and likely will) break without notice.
-	protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force = false) {
+	protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force, bool invalidate) {
 		if(hidden)
 			return;
 
@@ -1764,6 +1767,12 @@ class Widget : ReflectableProperties {
 			else
 				paint(painter);
 
+			if(invalidate) {
+				painter.invalidateRect(Rectangle(Point(clip.upperLeft.x - painter.originX, clip.upperRight.y - painter.originY), Size(clip.width, clip.height)));
+				// children are contained inside this, so no need to do extra work
+				invalidate = false;
+			}
+
 			redrawRequested = false;
 			actuallyPainted = true;
 		}
@@ -1771,14 +1780,14 @@ class Widget : ReflectableProperties {
 		foreach(child; children) {
 			version(win32_widgets)
 				if(child.useNativeDrawing()) continue;
-			child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted);
+			child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted, invalidate);
 		}
 
 		version(win32_widgets)
 		foreach(child; children) {
 			if(child.useNativeDrawing) {
-				painter = WidgetPainter(child.simpleWindowWrappingHwnd.draw, child);
+				painter = WidgetPainter(child.simpleWindowWrappingHwnd.draw(true), child);
-				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted);
+				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted, invalidate);
 			}
 		}
 	}
@@ -3104,8 +3113,10 @@ version(win32_widgets) {
 							// the event loop doesn't seem to carry on with a requested redraw..
 							// so we request it to get our dirty bit set...
 							// then we need to immediately actually redraw it too for instant feedback to user
-							if(this_.parentWindow)
+							SimpleWindow.processAllCustomEvents();
-								this_.parentWindow.actualRedraw();
+							SimpleWindow.processAllCustomEvents();
+							//if(this_.parentWindow)
+								//this_.parentWindow.actualRedraw();
 						return 0;
 						default:
 					}
@@ -4414,8 +4425,10 @@ class ScrollableWidget : Widget {
 							redraw();
 
 							// then we need to immediately actually redraw it too for instant feedback to user
-							if(parentWindow)
+
-								parentWindow.actualRedraw();
+							SimpleWindow.processAllCustomEvents();
+							//if(parentWindow)
+								//parentWindow.actualRedraw();
 						}
 					break;
 					default:
@@ -4691,9 +4704,9 @@ class ScrollableWidget : Widget {
 		}
 
 		//version(win32_widgets) {
-			//auto painter = simpleWindowWrappingHwnd ? simpleWindowWrappingHwnd.draw() : parentWindow.win.draw();
+			//auto painter = simpleWindowWrappingHwnd ? simpleWindowWrappingHwnd.draw(true) : parentWindow.win.draw(true);
 		//} else {
-			auto painter = parentWindow.win.draw();
+			auto painter = parentWindow.win.draw(true);
 		//}
 		painter.originX = x;
 		painter.originY = y;
@@ -4711,12 +4724,12 @@ class ScrollableWidget : Widget {
 // you need to have a Point scrollOrigin in the class somewhere
 // and a paintFrameAndBackground
 private mixin template ScrollableChildren() {
-	override protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force = false) {
+	override protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force, bool invalidate) {
 		if(hidden)
 			return;
 
 		//version(win32_widgets)
-			//painter = simpleWindowWrappingHwnd ? simpleWindowWrappingHwnd.draw() : parentWindow.win.draw();
+			//painter = simpleWindowWrappingHwnd ? simpleWindowWrappingHwnd.draw(true) : parentWindow.win.draw(true);
 
 		painter.originX = lox + x;
 		painter.originY = loy + y;
@@ -4745,14 +4758,21 @@ private mixin template ScrollableChildren() {
 			else
 				paint(painter);
 
+			if(invalidate) {
+				painter.invalidateRect(Rectangle(Point(clip.upperLeft.x - painter.originX, clip.upperRight.y - painter.originY), Size(clip.width, clip.height)));
+				// children are contained inside this, so no need to do extra work
+				invalidate = false;
+			}
+
+
 			actuallyPainted = true;
 			redrawRequested = false;
 		}
 		foreach(child; children) {
 			if(cast(FixedPosition) child)
-				child.privatePaint(painter, painter.originX + scrollOrigin.x, painter.originY + scrollOrigin.y, clip, actuallyPainted);
+				child.privatePaint(painter, painter.originX + scrollOrigin.x, painter.originY + scrollOrigin.y, clip, actuallyPainted, invalidate);
 			else
-				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted);
+				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted, invalidate);
 		}
 	}
 }
@@ -4766,7 +4786,7 @@ private class InternalScrollableContainerInsideWidget : ContainerWidget {
 	}
 
 	version(custom_widgets)
-	override protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force = false) {
+	override protected void privatePaint(WidgetPainter painter, int lox, int loy, Rectangle containment, bool force, bool invalidate) {
 		if(hidden)
 			return;
 
@@ -4774,7 +4794,7 @@ private class InternalScrollableContainerInsideWidget : ContainerWidget {
 
 		auto scrollOrigin = Point(scw.scrollX_, scw.scrollY_);
 
-		const clip = containment.intersectionOf(Rectangle(Point(lox + x, loy + y), Size(width, height)));
+		const clip = containment.intersectionOf(Rectangle(Point(lox + x, loy + y), Size(width + scw.scrollX_, height + scw.scrollY_)));
 		if(clip == Rectangle.init)
 			return;
 
@@ -4789,14 +4809,20 @@ private class InternalScrollableContainerInsideWidget : ContainerWidget {
 			else
 				paint(painter);
 
+			if(invalidate) {
+				painter.invalidateRect(Rectangle(Point(clip.upperLeft.x - painter.originX, clip.upperRight.y - painter.originY), Size(clip.width, clip.height)));
+				// children are contained inside this, so no need to do extra work
+				invalidate = false;
+			}
+
 			actuallyPainted = true;
 			redrawRequested = false;
 		}
 		foreach(child; children) {
 			if(cast(FixedPosition) child)
-				child.privatePaint(painter, painter.originX + scrollOrigin.x, painter.originY + scrollOrigin.y, clip, actuallyPainted);
+				child.privatePaint(painter, painter.originX + scrollOrigin.x, painter.originY + scrollOrigin.y, clip, actuallyPainted, invalidate);
 			else
-				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted);
+				child.privatePaint(painter, painter.originX, painter.originY, clip, actuallyPainted, invalidate);
 		}
 	}
 
@@ -4810,8 +4836,14 @@ private class InternalScrollableContainerInsideWidget : ContainerWidget {
 /++
 	A widget meant to contain other widgets that may need to scroll.
 
+	Currently buggy.
+
 	History:
 		Added July 1, 2021 (dub v10.2)
+
+		On January 3, 2022, I tried to use it in a few other cases
+		and found it only worked well in the original test case. Since
+		it still sucks, I think I'm going to rewrite it again.
 +/
 class ScrollableContainerWidget : ContainerWidget {
 	///
@@ -4897,8 +4929,9 @@ class ScrollableContainerWidget : ContainerWidget {
 		if(dx || dy) {
 			version(win32_widgets)
 				ScrollWindowEx(container.hwnd, -dx, -dy, null, null, null, null, SW_SCROLLCHILDREN | SW_INVALIDATE | SW_ERASE);
-			else
+			else {
 				redraw();
+			}
 
 			hsb.setPosition = nx;
 			vsb.setPosition = ny;
@@ -4964,7 +4997,20 @@ class ScrollableContainerWidget : ContainerWidget {
 		hsb.setPosition(0);
 		vsb.setPosition(0);
 
-		setTotalArea(this.ContainerWidget.minWidth(), this.ContainerWidget.minHeight());
+		int mw, mh;
+		Widget c = container;
+		// FIXME: hack here to handle a layout inside...
+		if(c.children.length == 1 && cast(Layout) c.children[0])
+			c = c.children[0];
+		foreach(child; c.children) {
+			auto w = child.x + child.width;
+			auto h = child.y + child.height;
+
+			if(w > mw) mw = w;
+			if(h > mh) mh = h;
+		}
+
+		setTotalArea(mw, mh);
 		setViewableArea(width, height);
 	}
 
@@ -6189,17 +6235,65 @@ class TabMessageWidget : Widget {
 		} else version(custom_widgets) {
 			if(pos >= tabs.length) {
 				tabs ~= title;
+				redraw();
 				return cast(int) tabs.length - 1;
 			} else if(pos <= 0) {
 				tabs = title ~ tabs;
+				redraw();
 				return 0;
 			} else {
 				tabs = tabs[0 .. pos] ~ title ~ title[pos .. $];
+				redraw();
 				return pos;
 			}
 		}
 	}
 
+	override void addChild(Widget child, int pos = int.max) {
+		if(container)
+			container.addChild(child, pos);
+		else
+			super.addChild(child, pos);
+	}
+
+	protected Widget makeContainer() {
+		return new Widget(this);
+	}
+
+	private Widget container;
+
+	override void recomputeChildLayout() {
+		version(win32_widgets) {
+			this.registerMovement();
+
+			RECT rect;
+			GetWindowRect(hwnd, &rect);
+
+			auto left = rect.left;
+			auto top = rect.top;
+
+			TabCtrl_AdjustRect(hwnd, false, &rect);
+			foreach(child; children) {
+				if(!child.showing) continue;
+				child.x = rect.left - left;
+				child.y = rect.top - top;
+				child.width = rect.right - rect.left;
+				child.height = rect.bottom - rect.top;
+				child.recomputeChildLayout();
+			}
+		} else version(custom_widgets) {
+			this.registerMovement();
+			foreach(child; children) {
+				if(!child.showing) continue;
+				child.x = 2;
+				child.y = tabBarHeight + 2; // for the border
+				child.width = width - 4; // for the border
+				child.height = height - tabBarHeight - 2 - 2; // for the border
+				child.recomputeChildLayout();
+			}
+		} else static assert(0);
+	}
+
 	version(custom_widgets)
 		string[] tabs;
 
@@ -6212,14 +6306,19 @@ class TabMessageWidget : Widget {
 			createWin32Window(this, WC_TABCONTROL, "", 0);
 		} else version(custom_widgets) {
 			addEventListener((ClickEvent event) {
-				if(event.target !is this) return;
+				if(event.target !is this && this.container !is null && event.target !is this.container) return;
 				if(event.clientY < tabBarHeight) {
 					auto t = (event.clientX / tabWidth);
-					if(t >= 0 && t < children.length)
+					if(t >= 0 && t < tabs.length) {
-						setCurrentTab(t);
+						currentTab_ = t;
+						tabIndexClicked(t);
+						redraw();
+					}
 				}
 			});
 		} else static assert(0);
+
+		this.container = makeContainer();
 	}
 
 	override int marginTop() { return 4; }
@@ -6353,9 +6452,13 @@ class TabWidget : TabMessageWidget {
 		super(parent);
 	}
 
+	override protected Widget makeContainer() {
+		return null;
+	}
+
 	override void addChild(Widget child, int pos = int.max) {
 		if(auto twp = cast(TabWidgetPage) child) {
-			super.addChild(child, pos);
+			Widget.addChild(child, pos);
 			if(pos == int.max)
 				pos = cast(int) this.children.length - 1;
 
@@ -6369,38 +6472,6 @@ class TabWidget : TabMessageWidget {
 		}
 	}
 
-	override void recomputeChildLayout() {
-		version(win32_widgets) {
-			this.registerMovement();
-
-			RECT rect;
-			GetWindowRect(hwnd, &rect);
-
-			auto left = rect.left;
-			auto top = rect.top;
-
-			TabCtrl_AdjustRect(hwnd, false, &rect);
-			foreach(child; children) {
-				if(!child.showing) continue;
-				child.x = rect.left - left;
-				child.y = rect.top - top;
-				child.width = rect.right - rect.left;
-				child.height = rect.bottom - rect.top;
-				child.recomputeChildLayout();
-			}
-		} else version(custom_widgets) {
-			this.registerMovement();
-			foreach(child; children) {
-				if(!child.showing) continue;
-				child.x = 2;
-				child.y = tabBarHeight + 2; // for the border
-				child.width = width - 4; // for the border
-				child.height = height - tabBarHeight - 2 - 2; // for the border
-				child.recomputeChildLayout();
-			}
-		} else static assert(0);
-	}
-
 	// FIXME: add tab icons at some point, Windows supports them
 	/++
 		Adds a page and its associated tab with the given label to the widget.
@@ -6973,6 +7044,14 @@ class ScrollMessageWidget : Widget {
 	HorizontalScrollbar horizontalScrollBar() { return hsb; }
 
 	void notify() {
+		static bool insideNotify;
+
+		if(insideNotify)
+			return; // avoid the recursive call, even if it isn't strictly correct
+
+		insideNotify = true;
+		scope(exit) insideNotify = false;
+
 		this.emit!ScrollEvent();
 	}
 
@@ -7002,11 +7081,13 @@ class ScrollMessageWidget : Widget {
 	}
 
 	/// Always set the viewable area AFTER setitng the total area if you are going to change both.
+	/// NEVER call this from inside a scroll event. This includes through recomputeChildLayout.
+	/// If you need to do that, use [queueRecomputeChildLayout].
 	void setViewableArea(int width, int height) {
 
-		if(width == hsb.viewableArea_ && height == vsb.viewableArea_)
+		// actually there IS A need to dothis cuz the max might have changed since then
-			return; // no need to do what is already done
+		//if(width == hsb.viewableArea_ && height == vsb.viewableArea_)
-
+			//return; // no need to do what is already done
 		hsb.setViewableArea(width);
 		vsb.setViewableArea(height);
 
@@ -7111,6 +7192,8 @@ unittest {
 	auto window = new Window("ScrollMessageWidget");
 
 	auto smw = new ScrollMessageWidget(window);
+	smw.addDefaultKeyboardListeners();
+	smw.addDefaultWheelListeners();
 
 	window.loop();
 }
@@ -7309,8 +7392,8 @@ class Window : Widget {
 			loy += ugh.y;
 			ugh = ugh.parent;
 		}
-		auto painter = w.draw();
+		auto painter = w.draw(true);
-		privatePaint(WidgetPainter(painter, this), lox, loy, Rectangle(0, 0, int.max, int.max));
+		privatePaint(WidgetPainter(painter, this), lox, loy, Rectangle(0, 0, int.max, int.max), false, true);
 	}
 
 
@@ -8700,25 +8783,56 @@ private string toMenuLabel(string s) {
 	return n;
 }
 
+private void autoExceptionHandler(Exception e) {
+	messageBox(e.msg);
+}
+
 private void delegate() makeAutomaticHandler(alias fn, T)(T t) {
 	static if(is(T : void delegate())) {
-		return t;
-	} else {
-		static if(is(typeof(fn) Params == __parameters))
-		struct S {
-			static if(!__traits(compiles, mixin(`{ static foreach(i; 1..4) {} }`))) {
-				pragma(msg, "warning: automatic handler of params not yet implemented on your compiler");
-			} else mixin(q{
-			static foreach(idx, ignore; Params) {
-				mixin("Params[idx] " ~ __traits(identifier, Params[idx .. idx + 1]) ~ ";");
-			}
-			});
-		}
 		return () {
-			dialog((S s) {
+			try
-				cast(void) t(s.tupleof);
+				t();
-			}, null, __traits(identifier, fn));
+			catch(Exception e)
+				autoExceptionHandler(e);
 		};
+	} else static if(is(typeof(fn) Params == __parameters)) {
+		static if(Params.length == 1 && is(Params[0] == FileName!(member, filters, type), alias member, string[] filters, FileDialogType type)) {
+			return () {
+				void onOK(string s) {
+					member = s;
+					try
+						t(Params[0](s));
+					catch(Exception e)
+						autoExceptionHandler(e);
+				}
+
+				if(
+					(type == FileDialogType.Automatic && (__traits(identifier, fn).startsWith("Save") || __traits(identifier, fn).startsWith("Export")))
+					|| type == FileDialogType.Save)
+				{
+					getSaveFileName(&onOK, member, filters, null);
+				} else
+					getOpenFileName(&onOK, member, filters, null);
+			};
+		} else {
+			struct S {
+				static if(!__traits(compiles, mixin(`{ static foreach(i; 1..4) {} }`))) {
+					pragma(msg, "warning: automatic handler of params not yet implemented on your compiler");
+				} else mixin(q{
+				static foreach(idx, ignore; Params) {
+					mixin("Params[idx] " ~ __traits(identifier, Params[idx .. idx + 1]) ~ ";");
+				}
+				});
+			}
+			return () {
+				dialog((S s) {
+					try
+						cast(void) t(s.tupleof);
+					catch(Exception e)
+						autoExceptionHandler(e);
+				}, null, __traits(identifier, fn));
+			};
+		}
 	}
 }
 
@@ -12748,6 +12862,33 @@ enum GenericIcons : ushort {
 	Print, ///
 }
 
+enum FileDialogType {
+	Automatic,
+	Open,
+	Save
+}
+string previousFileReferenced;
+
+/++
+	Used in automatic menu functions to indicate that the user should be able to browse for a file.
+
+	Params:
+		storage = an alias to a `static string` variable that stores the last file referenced. It will
+		use this to pre-fill the dialog with a suggestion.
+
+		Please note that it MUST be `static` or you will get compile errors.
+
+		filters = the filters param to [getFileName]
+
+		type = the type if dialog to show. If `FileDialogType.Automatic`, it the driver code will
+		guess based on the function name. If it has the word "Save" or "Export" in it, it will show
+		a save dialog box. Otherwise, it will show an open dialog box.
++/
+struct FileName(alias storage = previousFileReferenced, string[] filters = null, FileDialogType type = FileDialogType.Automatic) {
+	string name;
+	alias name this;
+}
+
 /++
 	History:
 		The dialog itself on Linux was modified on December 2, 2021 to include
@@ -12828,6 +12969,8 @@ void getFileName(
 				onCancel();
 		}
 	} else version(custom_widgets) {
+		if(filters.length == 0)
+			filters = ["All Files\0*.*"];
 		auto picker = new FilePicker(prefilledName, filters);
 		picker.onOK = onOK;
 		picker.onCancel = onCancel;
@@ -12915,6 +13058,7 @@ class FilePicker : Dialog {
 				foreach(filter; filters)
 				if(
 					filter.length <= 1 ||
+					filter == "*.*" ||
 					(filter[0] == '*' && name.endsWith(filter[1 .. $])) ||
 					(filter[$-1] == '*' && name.startsWith(filter[0 .. $ - 1]))
 				)
@@ -13235,10 +13379,21 @@ class ObjectInspectionWindowImpl(T) : ObjectInspectionWindow {
 		// you can check the members now
 	});
 	---
+
+	Params:
+		initialData = the initial value to show in the dialog. It will not modify this unless
+		it is a class then it might, no promises.
+
+	History:
+		The overload that lets you specify `initialData` was added on December 30, 2021 (dub v10.5)
 +/
 /// Group: generating_from_code
 void dialog(T)(void delegate(T) onOK, void delegate() onCancel = null, string title = T.stringof) {
-	auto dg = new AutomaticDialog!T(onOK, onCancel, title);
+	dialog(T.init, onOK, onCancel, title);
+}
+/// ditto
+void dialog(T)(T initialData, void delegate(T) onOK, void delegate() onCancel = null, string title = T.stringof) {
+	auto dg = new AutomaticDialog!T(initialData, onOK, onCancel, title);
 	dg.show();
 }
 
@@ -13301,10 +13456,15 @@ class AutomaticDialog(T) : Dialog {
 	override int paddingRight() { return defaultLineHeight; }
 	override int paddingLeft() { return defaultLineHeight; }
 
-	this(void delegate(T) onOK, void delegate() onCancel, string title) {
+	this(T initialData, void delegate(T) onOK, void delegate() onCancel, string title) {
 		assert(onOK !is null);
-		static if(is(T == class))
+
-			t = new T();
+		t = initialData;
+
+		static if(is(T == class)) {
+			if(t is null)
+				t = new T();
+		}
 		this.onOK = onOK;
 		this.onCancel = onCancel;
 		super(400, cast(int)(__traits(allMembers, T).length * 2) * (defaultLineHeight + 4 + 2) + Window.lineHeight + 56, title);

simpleaudio.d

@@ -1,4 +1,5 @@
 // FIXME: add a query devices thing
+// FIXME: add the alsa sequencer interface cuz then i don't need the virtual raw midi sigh. or at elast load "virtual" and auto connect it somehow
 /**
 	The purpose of this module is to provide audio functions for
 	things like playback, capture, and volume on both Windows
@@ -275,6 +276,26 @@ struct AudioOutputThread {
 		@disable new(); // but new dmd is strict about not allowing it
 
 	@disable void start() {} // you aren't supposed to control the thread yourself!
+	/++
+		You should call `exit` instead of join. It will signal the thread to exit and then call join for you.
+
+		If you absolutely must call join, use [rawJoin] instead.
+
+		History:
+			Disabled on December 30, 2021
+	+/
+	@disable void join(bool a = false) {} // you aren't supposed to control the thread yourself!
+
+	/++
+		Don't call this unless you're sure you know what you're doing.
+
+		You should use `audioOutputThread.exit();` instead.
+	+/
+	Throwable rawJoin(bool rethrow = true) {
+		if(impl is null)
+			return null;
+		return impl.join(rethrow);
+	}
 
 	/++
 		Pass `true` to enable the audio thread. Otherwise, it will
@@ -292,6 +313,7 @@ struct AudioOutputThread {
 			impl.refcount++;
 			impl.start();
 			impl.waitForInitialization();
+			impl.priority = Thread.PRIORITY_MAX;
 		}
 	}
 
@@ -311,12 +333,23 @@ struct AudioOutputThread {
 		if(impl) {
 			impl.refcount--;
 			if(impl.refcount == 0) {
-				impl.stop();
+				impl.exit(true);
-				impl.join();
 			}
 		}
 	}
 
+	/++
+		Returns true if the output is suspended. Use `suspend` and `unsuspend` to change this.
+
+		History:
+			Added December 21, 2021 (dub v10.5)
+	+/
+	bool suspended() {
+		if(impl)
+			return impl.suspended();
+		return true;
+	}
+
 	/++
 		This allows you to check `if(audio)` to see if it is enabled.
 	+/
@@ -414,6 +447,146 @@ struct AudioOutputThread {
 +/
 deprecated("Use AudioOutputThread instead.") class AudioPcmOutThread {}
 
+/+
+/++
+
++/
+void mmsleep(Duration time) {
+	version(Windows) {
+		static HANDLE timerQueue;
+
+		static HANDLE event;
+		if(event is null)
+			event = CreateEvent(null, false, false, null);
+
+		extern(Windows)
+		static void cb(PVOID ev, BOOLEAN) {
+			HANDLE e = cast(HANDLE) ev;
+			SetEvent(e);
+		}
+
+		//if(timerQueue is null)
+			//timerQueue = CreateTimerQueue();
+
+		// DeleteTimerQueueEx(timerQueue, null);
+
+		HANDLE nt;
+		auto ret = CreateTimerQueueTimer(&nt, timerQueue, &cb, event /+ param +/, cast(DWORD) time.total!"msecs", 0 /* period */, WT_EXECUTEDEFAULT);
+		if(!ret)
+			throw new Exception("fail");
+		//DeleteTimerQueueTimer(timerQueue, nt, INVALID_HANDLE_VALUE);
+
+		WaitForSingleObject(event, 1000);
+	}
+}
++/
+
+/++
+	A clock you can use for multimedia applications. It compares time elapsed against
+	a position variable you pass in to figure out how long to wait to get to that point.
+	Very similar to Phobos' [std.datetime.stopwatch.StopWatch|StopWatch] but with built-in
+	wait capabilities.
+
+
+	For example, suppose you want something to happen 60 frames per second:
+
+	---
+	MMClock clock;
+	Duration frame;
+	clock.restart();
+	while(running) {
+		frame += 1.seconds / 60;
+		bool onSchedule = clock.waitUntil(frame);
+
+		do_essential_frame_work();
+
+		if(onSchedule) {
+			// if we're on time, do other work too.
+			// but if we weren't on time, skipping this
+			// might help catch back up to where we're
+			// supposed to be.
+
+			do_would_be_nice_frame_work();
+		}
+	}
+	---
++/
+struct MMClock {
+	import core.time;
+
+	private Duration position;
+	private MonoTime lastPositionUpdate;
+	private bool paused;
+	int speed = 1000; /// 1000 = 1.0, 2000 = 2.0, 500 = 0.5, etc.
+
+	private void updatePosition() {
+		auto now = MonoTime.currTime;
+		position += (now - lastPositionUpdate) * speed / 1000;
+		lastPositionUpdate = now;
+	}
+
+	/++
+		Restarts the clock from position zero.
+	+/
+	void restart() {
+		position = Duration.init;
+		lastPositionUpdate = MonoTime.currTime;
+	}
+
+	/++
+		Pauses the clock.
+	+/
+	void pause() {
+		if(paused) return;
+		updatePosition();
+		paused = true;
+	}
+	void unpause() {
+		if(!paused) return;
+		lastPositionUpdate = MonoTime.currTime;
+		paused = false;
+	}
+	/++
+		Goes to sleep until the real clock catches up to the given
+		`position`.
+
+		Returns: `true` if you're on schedule, returns false if the
+		given `position` is already in the past. In that case,
+		you might want to consider skipping some work to get back
+		on time.
+	+/
+	bool waitUntil(Duration position) {
+		auto diff = timeUntil(position);
+		if(diff < 0.msecs)
+			return false;
+
+		if(diff == 0.msecs)
+			return true;
+
+		import core.thread;
+		Thread.sleep(diff);
+		return true;
+	}
+
+	/++
+
+	+/
+	Duration timeUntil(Duration position) {
+		updatePosition();
+		return (position - this.position) * 1000 / speed;
+	}
+
+	/++
+		Returns the current time on the clock since the
+		last call to [restart], excluding times when the
+		clock was paused.
+	+/
+	Duration currentPosition() {
+		updatePosition();
+		return position;
+	}
+}
+
 import core.thread;
 /++
 	Makes an audio thread for you that you can make
@@ -450,15 +623,23 @@ final class AudioPcmOutThreadImplementation : Thread {
 
 	private void waitForInitialization() {
 		shared(AudioOutput*)* ao = cast(shared(AudioOutput*)*) &this.ao;
+		//int wait = 0;
 		while(isRunning && *ao is null) {
 			Thread.sleep(5.msecs);
+			//wait += 5;
 		}
 
-		if(*ao is null)
+		//import std.stdio; writeln(wait);
-			join(); // it couldn't initialize, just rethrow the exception
+
+		if(*ao is null) {
+			exit(true);
+		}
 	}
 
-	///
+	/++
+		Asks the device to pause/unpause. This may not actually do anything on some systems.
+		You should probably use [suspend] and [unsuspend] instead.
+	+/
 	@scriptable
 	void pause() {
 		if(ao) {
@@ -466,7 +647,7 @@ final class AudioPcmOutThreadImplementation : Thread {
 		}
 	}
 
-	///
+	/// ditto
 	@scriptable
 	void unpause() {
 		if(ao) {
@@ -474,13 +655,36 @@ final class AudioPcmOutThreadImplementation : Thread {
 		}
 	}
 
-	/// Stops the output thread. Using the object after it is stopped is not recommended, except to `join` the thread. This is meant to be called when you are all done with it.
+	/++
+		Stops the output thread. Using the object after it is stopped is not recommended which is why
+		this is now deprecated.
+
+		You probably want [suspend] or [exit] instead. Use [suspend] if you want to stop playing, and
+		close the output device, but keep the thread alive so you can [unsuspend] later. After calling
+		[suspend], you can call [unsuspend] and then continue using the other method normally again.
+
+		Use [exit] if you want to stop playing, close the output device, and terminate the worker thread.
+		After calling [exit], you may not call any methods on the thread again.
+
+		The one exception is if you are inside an audio callback and want to stop the thread and prepare
+		it to be [AudioOutputThread.rawJoin]ed. Preferably, you'd avoid doing this - the channels can
+		simply return false to indicate that they are done. But if you must do that, call [rawStop] instead.
+
+		History:
+			`stop` was deprecated and `rawStop` added on December 30, 2021 (dub v10.5)
+	+/
+	deprecated("You want to use either suspend or exit instead, or rawStop if you must but see the docs.")
 	void stop() {
 		if(ao) {
 			ao.stop();
 		}
 	}
 
+	/// ditto
+	void rawStop() {
+		if(ao) { ao.stop(); }
+	}
+
 	/++
 		Makes some old-school style sound effects. Play with them to see what they actually sound like.
 
@@ -1204,6 +1408,64 @@ final class AudioPcmOutThreadImplementation : Thread {
 		int fillDatasLength = 0;
 	}
 
+
+	private bool suspendWanted;
+	private bool exiting;
+
+	private bool suspended_;
+
+	/++
+		Stops playing and closes the audio device, but keeps the worker thread
+		alive and waiting for a call to [unsuspend], which will re-open everything
+		and pick up (close to; a couple buffers may be discarded) where it left off.
+
+		This is more reliable than [pause] and [unpause] since it doesn't require
+		the system/hardware to cooperate.
+
+		History:
+			Added December 30, 2021 (dub v10.5)
+	+/
+	public void suspend() {
+		suspended_ = true;
+		suspendWanted = true;
+		if(ao)
+			ao.stop();
+	}
+
+	/// ditto
+	public void unsuspend() {
+		suspended_ = false;
+		suspendWanted = false;
+		event.set();
+	}
+
+	/// ditto
+	public bool suspended() {
+		return suspended_;
+	}
+
+	/++
+		Stops playback and unsupends if necessary and exits.
+
+		Call this instead of join.
+
+		Please note: you should never call this from inside an audio
+		callback, as it will crash or deadlock. Instead, just return false
+		from your buffer fill function to indicate that you are done.
+
+		History:
+			Added December 30, 2021 (dub v10.5)
+	+/
+	public Throwable exit(bool rethrow = false) {
+		exiting = true;
+		unsuspend();
+		if(ao)
+			ao.stop();
+
+		return join(rethrow);
+	}
+
+
 	private void run() {
 		version(linux) {
 			// this thread has no business intercepting signals from the main thread,
@@ -1221,6 +1483,7 @@ final class AudioPcmOutThreadImplementation : Thread {
 		}
 
 		AudioOutput ao = AudioOutput(device, SampleRate, channels);
+
 		this.ao = &ao;
 		scope(exit) this.ao = null;
 		auto omg = this;
@@ -1262,6 +1525,7 @@ final class AudioPcmOutThreadImplementation : Thread {
 			}
 		};
 		//try
+		resume_from_suspend:
 		ao.play();
 		/+
 		catch(Throwable t) {
@@ -1269,7 +1533,46 @@ final class AudioPcmOutThreadImplementation : Thread {
 			writeln(t);
 		}
 		+/
+
+		if(suspendWanted) {
+			ao.close();
+
+			event.initialize(true, false);
+			if(event.wait() && !exiting) {
+				event.reset();
+
+				ao.open();
+				goto resume_from_suspend;
+			}
+		}
+
+		event.terminate();
 	}
+
+	static if(__VERSION__ > 2080) {
+		import core.sync.event;
+	} else {
+		// bad emulation of the Event but meh
+		static struct Event {
+			void terminate() {}
+			void initialize(bool, bool) {}
+
+			bool isSet;
+
+			void set() { isSet = true; }
+			void reset() { isSet = false; }
+			bool wait() {
+				while(!isSet) {
+					Thread.sleep(500.msecs);
+				}
+				isSet = false;
+				return true;
+			}
+
+		}
+	}
+
+	Event event;
 }
 
 
@@ -1522,6 +1825,7 @@ struct AudioOutput {
 
 	private int SampleRate;
 	private int channels;
+	private string device;
 
 	/++
 		`device` is a device name. On Linux, it is the ALSA string.
@@ -1536,21 +1840,9 @@ struct AudioOutput {
 
 		this.SampleRate = SampleRate;
 		this.channels = channels;
+		this.device = device;
 
-		version(ALSA) {
+		open();
-			handle = openAlsaPcm(snd_pcm_stream_t.SND_PCM_STREAM_PLAYBACK, SampleRate, channels, device);
-		} else version(WinMM) {
-			WAVEFORMATEX format;
-			format.wFormatTag = WAVE_FORMAT_PCM;
-			format.nChannels = cast(ushort) channels;
-			format.nSamplesPerSec = SampleRate;
-			format.nAvgBytesPerSec = SampleRate * channels * 2; // two channels, two bytes per sample
-			format.nBlockAlign = 4;
-			format.wBitsPerSample = 16;
-			format.cbSize = 0;
-			if(auto err = waveOutOpen(&handle, WAVE_MAPPER, &format, cast(DWORD_PTR) &mmCallback, cast(DWORD_PTR) &this, CALLBACK_FUNCTION))
-				throw new WinMMException("wave out open", err);
-		} else static assert(0);
 	}
 
 	/// Always pass card == 0.
@@ -1571,6 +1863,9 @@ struct AudioOutput {
 
 	/// Starts playing, loops until stop is called
 	void play() {
+		if(handle is null)
+			open();
+
 		assert(fillData !is null);
 		playing = true;
 
@@ -1680,6 +1975,8 @@ struct AudioOutput {
 				if(auto err = waveOutUnprepareHeader(handle, &header, header.sizeof))
 					throw new WinMMException("unprepare", err);
 		} else static assert(0);
+
+		close();
 	}
 
 	/// Breaks the play loop
@@ -1719,14 +2016,55 @@ struct AudioOutput {
 		}
 	}
 
+
+	/++
+		Re-opens the audio device that you have previously [close]d.
+
+		History:
+			Added December 30, 2021
+	+/
+	void open() {
+		assert(handle is null);
+		assert(!playing);
+		version(ALSA) {
+			handle = openAlsaPcm(snd_pcm_stream_t.SND_PCM_STREAM_PLAYBACK, SampleRate, channels, device);
+		} else version(WinMM) {
+			WAVEFORMATEX format;
+			format.wFormatTag = WAVE_FORMAT_PCM;
+			format.nChannels = cast(ushort) channels;
+			format.nSamplesPerSec = SampleRate;
+			format.nAvgBytesPerSec = SampleRate * channels * 2; // two channels, two bytes per sample
+			format.nBlockAlign = 4;
+			format.wBitsPerSample = 16;
+			format.cbSize = 0;
+			if(auto err = waveOutOpen(&handle, WAVE_MAPPER, &format, cast(DWORD_PTR) &mmCallback, cast(DWORD_PTR) &this, CALLBACK_FUNCTION))
+				throw new WinMMException("wave out open", err);
+		} else static assert(0);
+	}
+
+	/++
+		Closes the audio device. You MUST call [stop] before calling this.
+
+		History:
+			Added December 30, 2021
+	+/
+	void close() {
+		if(!handle)
+			return;
+		assert(!playing);
+		version(ALSA) {
+			snd_pcm_close(handle);
+			handle = null;
+		} else version(WinMM) {
+			waveOutClose(handle);
+			handle = null;
+		} else static assert(0);
+	}
+
 	// FIXME: add async function hooks
 
 	~this() {
-		version(ALSA) {
+		close();
-			snd_pcm_close(handle);
-		} else version(WinMM) {
-			waveOutClose(handle);
-		} else static assert(0);
 	}
 }
 
@@ -1853,23 +2191,6 @@ B0 40 00 # sustain pedal off
 	}
 }
 
-// plays a midi file in the background with methods to tweak song as it plays
-struct MidiOutputThread {
-	void injectCommand() {}
-	void pause() {}
-	void unpause() {}
-
-	void trackEnabled(bool on) {}
-	void channelEnabled(bool on) {}
-
-	void loopEnabled(bool on) {}
-
-	// stops the current song, pushing its position to the stack for later
-	void pushSong() {}
-	// restores a popped song from where it was.
-	void popSong() {}
-}
-
 version(Posix) {
 	import core.sys.posix.signal;
 	private sigaction_t oldSigIntr;
@@ -1916,10 +2237,18 @@ struct MidiOutput {
 		On Windows, it is currently ignored, so you should pass "default"
 		or null so when it does get implemented your code won't break.
 
+		If you pass the string "DUMMY", it will not actually open a device
+		and simply be a do-nothing mock object;
+
 		History:
 			Added Nov 8, 2020.
+
+			Support for the "DUMMY" device was added on January 2, 2022.
 	+/
 	this(string device) {
+		if(device == "DUMMY")
+			return;
+
 		version(ALSA) {
 			if(auto err = snd_rawmidi_open(null, &handle, device.toStringz, 0))
 				throw new AlsaException("rawmidi open", err);
@@ -1936,10 +2265,10 @@ struct MidiOutput {
 
 	/// Send a reset message, silencing all notes
 	void reset() {
+		if(!handle) return;
+
 		version(ALSA) {
-			static immutable ubyte[3] resetSequence = [0x0b << 4, 123, 0];
+			silenceAllNotes();
-			// send a controller event to reset it
-			writeRawMessageData(resetSequence[]);
 			static immutable ubyte[1] resetCmd = [0xff];
 			writeRawMessageData(resetCmd[]);
 			// and flush it immediately
@@ -1953,6 +2282,7 @@ struct MidiOutput {
 	/// Writes a single low-level midi message
 	/// Timing and sending sane data is your responsibility!
 	void writeMidiMessage(int status, int param1, int param2) {
+		if(!handle) return;
 		version(ALSA) {
 			ubyte[3] dataBuffer;
 
@@ -1980,6 +2310,7 @@ struct MidiOutput {
 	/// Timing and sending sane data is your responsibility!
 	/// The data should NOT include any timestamp bytes - each midi message should be 2 or 3 bytes.
 	void writeRawMessageData(scope const(ubyte)[] data) {
+		if(!handle) return;
 		if(data.length == 0)
 			return;
 		version(ALSA) {
@@ -2006,6 +2337,7 @@ struct MidiOutput {
 	}
 
 	~this() {
+		if(!handle) return;
 		version(ALSA) {
 			snd_rawmidi_close(handle);
 		} else version(WinMM) {

simpledisplay.d

@@ -2591,9 +2591,26 @@ class SimpleWindow : CapableOfHandlingNativeEvent, CapableOfBeingDrawnUpon {
 
 		Returns: an instance of [ScreenPainter], which has the drawing methods
 		on it to draw on this window.
+
+		Params:
+			manualInvalidations = if you set this to true, you will need to
+			set the invalid rectangle on the painter yourself. If false, it
+			assumes the whole window has been redrawn each time you draw.
+
+			Only invalidated rectangles are blitted back to the window when
+			the destructor runs. Doing this yourself can reduce flickering
+			of child windows.
+
+		History:
+			The `manualInvalidations` parameter overload was added on
+			December 30, 2021 (dub v10.5)
 	+/
 	ScreenPainter draw() {
-		return impl.getPainter();
+		return draw(false);
+	}
+	/// ditto
+	ScreenPainter draw(bool manualInvalidations) {
+		return impl.getPainter(manualInvalidations);
 	}
 
 	// This is here to implement the interface we use for various native handlers.
@@ -3416,7 +3433,7 @@ private:
 	}
 
 	// for all windows in nativeMapping
-	static void processAllCustomEvents () {
+	package static void processAllCustomEvents () {
 
 		justCommunication.processCustomEvents();
 
@@ -8532,7 +8549,7 @@ private inout(char)[] sliceCString(inout(char)* s) {
 */
 struct ScreenPainter {
 	CapableOfBeingDrawnUpon window;
-	this(CapableOfBeingDrawnUpon window, NativeWindowHandle handle) {
+	this(CapableOfBeingDrawnUpon window, NativeWindowHandle handle, bool manualInvalidations) {
 		this.window = window;
 		if(window.closed)
 			return; // null painter is now allowed so no need to throw anymore, this likely happens at the end of a program anyway
@@ -8544,6 +8561,7 @@ struct ScreenPainter {
 				impl.window = window;
 				impl.create(handle);
 			}
+			impl.manualInvalidations = manualInvalidations;
 			impl.referenceCount++;
 		//	writeln("refcount ++ ", impl.referenceCount);
 		} else {
@@ -8551,6 +8569,7 @@ struct ScreenPainter {
 			impl.window = window;
 			impl.create(handle);
 			impl.referenceCount = 1;
+			impl.manualInvalidations = manualInvalidations;
 			window.activeScreenPainter = impl;
 			//import std.stdio; writeln("constructed");
 		}
@@ -8558,6 +8577,28 @@ struct ScreenPainter {
 		copyActiveOriginals();
 	}
 
+	/++
+		If you are using manual invalidations, this informs the
+		window system that a section needs to be redrawn.
+
+		If you didn't opt into manual invalidation, you don't
+		have to call this.
+
+		History:
+			Added December 30, 2021 (dub v10.5)
+	+/
+	void invalidateRect(Rectangle rect) {
+		if(impl is null) return;
+
+		// transform(rect)
+		rect.left += _originX;
+		rect.right += _originX;
+		rect.top += _originY;
+		rect.bottom += _originY;
+
+		impl.invalidateRect(rect);
+	}
+
 	private Pen originalPen;
 	private Color originalFillColor;
 	private arsd.color.Rectangle originalClipRectangle;
@@ -9031,7 +9072,7 @@ class Sprite : CapableOfBeingDrawnUpon {
 
 	///
 	ScreenPainter draw() {
-		return ScreenPainter(this, handle);
+		return ScreenPainter(this, handle, false);
 	}
 
 	/++
@@ -10760,14 +10801,26 @@ version(Windows) {
 		// just because we can on Windows...
 		//void create(Image image);
 
+		void invalidateRect(Rectangle invalidRect) {
+			RECT rect;
+			rect.left = invalidRect.left;
+			rect.right = invalidRect.right;
+			rect.top = invalidRect.top;
+			rect.bottom = invalidRect.bottom;
+			InvalidateRect(hwnd, &rect, false);
+		}
+		bool manualInvalidations;
+
 		void dispose() {
 			// FIXME: this.window.width/height is probably wrong
 			// BitBlt(windowHdc, 0, 0, this.window.width, this.window.height, hdc, 0, 0, SRCCOPY);
 			// ReleaseDC(hwnd, windowHdc);
 
 			// FIXME: it shouldn't invalidate the whole thing in all cases... it would be ideal to do this right
-			if(cast(SimpleWindow) this.window)
+			if(cast(SimpleWindow) this.window) {
-			InvalidateRect(hwnd, cast(RECT*)null, false); // no need to erase bg as the whole thing gets bitblt'd ove
+				if(!manualInvalidations)
+					InvalidateRect(hwnd, cast(RECT*)null, false); // no need to erase bg as the whole thing gets bitblt'd ove
+			}
 
 			if(originalPen !is null)
 				SelectObject(hdc, originalPen);
@@ -11064,8 +11117,8 @@ version(Windows) {
 		// though it is nonessential anyway.
 		void setResizeGranularity (int granx, int grany) {}
 
-		ScreenPainter getPainter() {
+		ScreenPainter getPainter(bool manualInvalidations) {
-			return ScreenPainter(this, hwnd);
+			return ScreenPainter(this, hwnd, manualInvalidations);
 		}
 
 		HBITMAP buffer;
@@ -11604,6 +11657,14 @@ version(Windows) {
 					if(this.onDpiChanged)
 						this.onDpiChanged();
 				break;
+				case WM_ENTERIDLE:
+					// when a menu is up, it stops normal event processing (modal message loop)
+					// but this at least gives us a chance to SOMETIMES catch up
+					// FIXME: I can use SetTimer while idle to keep working i think... but idk when i'd destroy it.
+					SimpleWindow.processAllCustomEvents;
+					SimpleWindow.processAllCustomEvents;
+					SleepEx(0, true);
+					break;
 				case WM_SIZE:
 					if(wParam == 1 /* SIZE_MINIMIZED */)
 						break;
@@ -11678,6 +11739,9 @@ version(Windows) {
 
 					if(windowResized !is null)
 						windowResized(width, height);
+
+					if(inSizeMove)
+						SimpleWindow.processAllCustomEvents();
 				break;
 				case WM_ERASEBKGND:
 					// call `visibleForTheFirstTime` here, so we can do initialization as early as possible
@@ -12061,6 +12125,11 @@ version(X11) {
 
 		private Picture xrenderPicturePainter;
 
+		bool manualInvalidations;
+		void invalidateRect(Rectangle invalidRect) {
+			// FIXME if manualInvalidations
+		}
+
 		void dispose() {
 			this.rasterOp = RasterOp.normal;
 
@@ -12073,6 +12142,8 @@ version(X11) {
 
 			// src x,y     then dest x, y
 			if(destiny != None) {
+				// FIXME: if manual invalidations we can actually only copy some of the area.
+				// if(manualInvalidations)
 				XSetClipMask(display, gc, None);
 				XCopyArea(display, d, destiny, gc, 0, 0, this.window.width, this.window.height, 0, 0);
 			}
@@ -12358,14 +12429,16 @@ version(X11) {
 			int cy = y;
 
 			if(alignment & TextAlignment.VerticalBottom) {
-				assert(y2);
+				if(y2 <= 0)
+					return;
 				auto h = y2 - y;
 				if(h > textHeight) {
 					cy += h - textHeight;
 					cy -= lineHeight / 2;
 				}
 			} else if(alignment & TextAlignment.VerticalCenter) {
-				assert(y2);
+				if(y2 <= 0)
+					return;
 				auto h = y2 - y;
 				if(textHeight < h) {
 					cy += (h - textHeight) / 2;
@@ -12379,12 +12452,14 @@ version(X11) {
 				int px = x, py = cy;
 
 				if(alignment & TextAlignment.Center) {
-					assert(x2);
+					if(x2 <= 0)
+						return;
 					auto w = x2 - x;
 					if(w > textWidth)
 						px += (w - textWidth) / 2;
 				} else if(alignment & TextAlignment.Right) {
-					assert(x2);
+					if(x2 <= 0)
+						return;
 					auto pos = x2 - textWidth;
 					if(pos > x)
 						px = pos;
@@ -13801,8 +13876,8 @@ mixin DynamicLoad!(XRandr, "Xrandr", 2, XRandrLibrarySuccessfullyLoaded) XRandrL
 			}
 		}
 
-		ScreenPainter getPainter() {
+		ScreenPainter getPainter(bool manualInvalidations) {
-			return ScreenPainter(this, window);
+			return ScreenPainter(this, window, manualInvalidations);
 		}
 
 		void move(int x, int y) {
@@ -17178,6 +17253,9 @@ version(OSXCocoa) {
             	setNeedsDisplay(view, true);
         }
 
+	bool manualInvalidations;
+	void invalidateRect(Rectangle invalidRect) { }
+
 	// NotYetImplementedException
 	Size textSize(in char[] txt) { return Size(32, 16); throw new NotYetImplementedException(); }
 	void rasterOp(RasterOp op) {}
@@ -17353,8 +17431,8 @@ version(OSXCocoa) {
             .close(window);
         }
 
-        ScreenPainter getPainter() {
+        ScreenPainter getPainter(bool manualInvalidations) {
-		return ScreenPainter(this, this);
+		return ScreenPainter(this, this, manualInvalidations);
 	}
 
         id window;