fixup webfreaks PR

simpledisplay.d

@@ -4419,8 +4419,8 @@ enum RasterOp {
 
 // being phobos-free keeps the size WAY down
 private const(char)* toStringz(string s) { return (s ~ '\0').ptr; }
-private const(wchar)* toWStringz(wstring s) { return (s ~ '\0').ptr; }
+package(arsd) const(wchar)* toWStringz(wstring s) { return (s ~ '\0').ptr; }
-private const(wchar)* toWStringz(string s) {
+package(arsd) const(wchar)* toWStringz(string s) {
 	wstring r;
 	foreach(dchar c; s)
 		r ~= c;
@@ -7269,7 +7269,7 @@ version(Windows) {
 			if (!len)
 				return null;
 			char[] buffer = new char[len];
-			auto len2 = GetWindowTextA(hwnd, buffer.ptr, buffer.length);
+			auto len2 = GetWindowTextA(hwnd, buffer.ptr, cast(int) buffer.length);
 			if (len != len2)
 				throw new Exception("Window title changed while checking");
 			return cast(string)buffer;

wmutil.d

@@ -1,49 +1,61 @@
 /++
 	Cross platform window manager utilities for interacting with other unknown windows on the OS.
 
-	Based on arsd.simpledisplay.
+	Based on [arsd.simpledisplay].
 +/
 module arsd.wmutil;
 
 public import arsd.simpledisplay;
 
+version(Windows)
+	import core.sys.windows.windows;
+
 static assert(UsingSimpledisplayX11 || UsingSimpledisplayWindows, "wmutil only works on X11 or Windows");
 
-static if (UsingSimpledisplayX11)
+static if (UsingSimpledisplayX11) {
-{
+	extern(C) nothrow @nogc {
-extern(C) nothrow @nogc {
+		Atom* XListProperties(Display *display, Window w, int *num_prop_return);
-Atom* XListProperties(Display *display, Window w, int *num_prop_return);
+		Status XGetTextProperty(Display *display, Window w, XTextProperty *text_prop_return, Atom property);
-Status XGetTextProperty(Display *display, Window w, XTextProperty *text_prop_return, Atom property);
+		Status XQueryTree(Display *display, Window w, Window *root_return, Window *parent_return, Window **children_return, uint *nchildren_return);
-Status XQueryTree(Display *display, Window w, Window *root_return, Window *parent_return, Window **children_return, uint *nchildren_return);
+	}
-}
 }
 
+/// A foreachable object that iterates window children
 struct WindowChildrenIterator {
 	NativeWindowHandle parent;
 
+	version(Windows)
+	struct EnumParams {
+		int result;
+		int delegate(NativeWindowHandle) dg;
+		Exception ex;
+	}
+
+
+
+	version(Windows)
+	extern(Windows)
+	nothrow private static int helper(HWND window, LPARAM lparam) {
+		EnumParams* args = cast(EnumParams*)lparam;
+		try {
+			args.result = args.dg(window);
+			if (args.result)
+				return 0;
+			else
+				return 1;
+		} catch (Exception e) {
+			args.ex = e;
+			return 0;
+		}
+	}
+
+	///
 	int opApply(int delegate(NativeWindowHandle) dg) const {
 		version (Windows) {
-			struct EnumParams {
-				int result;
-				int delegate(NativeWindowHandle) dg;
-				Exception ex;
-			}
-
 			EnumParams params;
 
-			EnumChildWindows(parent, function (window, lparam) nothrow {
+			// the cast is cuz druntime seems to have a wrong definition here, missing the const
-				EnumParams* args = cast(EnumParams*)lparam;
+			EnumChildWindows(cast(void*) parent, &helper, cast(LPARAM)&params);
-				try {
-					args.result = args.dg(window);
-					if (args.result)
-						return 0;
-					else
-						return 1;
-				} catch (Exception e) {
-					args.ex = e;
-					return 0;
-				}
-			}, cast(LPARAM)&params);
 
 			if (params.ex)
 				throw params.ex;
@@ -67,11 +79,12 @@ struct WindowChildrenIterator {
 			}
 			return result;
 		} else
-			throw new NotYetImplementedException();
+			static assert(0);
 		
 	}
 }
 
+///
 WindowChildrenIterator iterateWindows(NativeWindowHandle parent = NativeWindowHandle.init) {
 	static if (UsingSimpledisplayX11)
 		if (parent == NativeWindowHandle.init)
@@ -86,71 +99,68 @@ WindowChildrenIterator iterateWindows(NativeWindowHandle parent = NativeWindowHa
 	Params:
 		className = the class name to check the window for, case-insensitive.
 +/
+NativeWindowHandle findWindowByClass(string className) {
+	version (Windows)
+		return findWindowByClass(className.toWStringz);
+	else static if (UsingSimpledisplayX11) {
+		import std.algorithm : splitter;
+		import std.uni : sicmp;
+
+		auto classAtom = GetAtom!"WM_CLASS"(XDisplayConnection.get());
+		Atom returnType;
+		int returnFormat;
+		arch_ulong numItems, bytesAfter;
+		char* strs;
+		foreach (window; iterateWindows) {
+			if (0 == XGetWindowProperty(XDisplayConnection.get(), window, classAtom, 0, 64, false, AnyPropertyType, &returnType, &returnFormat, &numItems, &bytesAfter, cast(void**)&strs)) {
+				scope (exit)
+					XFree(strs);
+				if (returnFormat == 8) {
+					foreach (windowClassName; strs[0 .. numItems].splitter('\0')) {
+						if (sicmp(windowClassName, className) == 0)
+							return window;
+					}
+				}
+			}
+		}
+		return NativeWindowHandle.init;
+
+	}
+}
+
+/// ditto
 version (Windows)
 NativeWindowHandle findWindowByClass(LPCTSTR className) {
 	return FindWindow(className, null);
 }
 
-/// ditto
-version (Windows)
-NativeWindowHandle findWindowByClass(string className) {
-	return findWindowByClass(className.toWStringz);
-}
-
-/// ditto
-static if (UsingSimpledisplayX11)
-NativeWindowHandle findWindowByClass(string className) {
-	import std.algorithm : splitter;
-	import std.uni : sicmp;
-
-	auto classAtom = GetAtom!"WM_CLASS"(XDisplayConnection.get());
-	Atom returnType;
-	int returnFormat;
-	arch_ulong numItems, bytesAfter;
-	char* strs;
-	foreach (window; iterateWindows) {
-		if (0 == XGetWindowProperty(XDisplayConnection.get(), window, classAtom, 0, 64, false, AnyPropertyType, &returnType, &returnFormat, &numItems, &bytesAfter, cast(void**)&strs)) {
-			scope (exit)
-				XFree(strs);
-			if (returnFormat == 8) {
-				foreach (windowClassName; strs[0 .. numItems].splitter('\0')) {
-					if (sicmp(windowClassName, className) == 0)
-						return window;
-				}
-			}
-		}
-	}
-	return NativeWindowHandle.init;
-}
-
 /++
+	Get the PID that owns the window.
+
 	Params:
 		window = The window to check who created it
 	Returns: the PID of the owner who created this window. On windows this will always work and be accurate. On X11 this might return -1 if none is specified and might not actually be the actual owner.
 +/
-version (Windows)
 int ownerPID(NativeWindowHandle window) @property {
-	DWORD ret;
+	version (Windows) {
-	GetWindowThreadProcessId(window, &ret);
+		DWORD ret;
-	return cast(int)ret;
+		GetWindowThreadProcessId(window, &ret);
-}
+		return cast(int) ret;
-
+	} else static if (UsingSimpledisplayX11) {
-/// ditto
+		auto pidAtom = GetAtom!"_NET_WM_PID"(XDisplayConnection.get());
-static if (UsingSimpledisplayX11)
+		Atom returnType;
-int ownerPID(NativeWindowHandle window) @property {
+		int returnFormat;
-	auto pidAtom = GetAtom!"_NET_WM_PID"(XDisplayConnection.get());
+		arch_ulong numItems, bytesAfter;
-	Atom returnType;
+		uint* ints;
-	int returnFormat;
+		if (0 == XGetWindowProperty(XDisplayConnection.get(), window, pidAtom, 0, 1, false, AnyPropertyType, &returnType, &returnFormat, &numItems, &bytesAfter, cast(void**)&ints)) {
-	arch_ulong numItems, bytesAfter;
+			scope (exit)
-	uint* ints;
+				XFree(ints);
-	if (0 == XGetWindowProperty(XDisplayConnection.get(), window, pidAtom, 0, 1, false, AnyPropertyType, &returnType, &returnFormat, &numItems, &bytesAfter, cast(void**)&ints)) {
+			if (returnFormat < 64 && numItems > 0) {
-		scope (exit)
+				return *ints;
-			XFree(ints);
+			}
-		if (returnFormat < 64 && numItems > 0) {
-			return *ints;
 		}
+		return -1;
 	}
-	return -1;
 }
 
 unittest {