Merge pull request #267 from native-window-decorations

Native window decorations for Windows 10 (using JNI)

flatlaf-natives/README.md

@@ -0,0 +1,5 @@
+FlatLaf Native Libraries
+========================
+
+- [Windows 10 Native Library](flatlaf-natives-windows)
+- [Natives using JNA](flatlaf-natives-jna) (for development only)

flatlaf-natives/flatlaf-natives-jna/README.md

@@ -0,0 +1,10 @@
+FlatLaf Natives using JNA
+=========================
+
+This sub-project contains source code that uses
+[JNA](https://github.com/java-native-access/jna) to access native operating
+system API.
+
+**Note:** Code in this sub-project is **not used** in FlatLaf libraries. It was
+used to develop/test usage of some native operating system API in Java (with the
+help of JNA) and was then converted to C++.

flatlaf-natives/flatlaf-natives-jna/src/main/java/com/formdev/flatlaf/natives/jna/windows/FlatWindowsNativeWindowBorder.java

@@ -207,20 +207,20 @@ public class FlatWindowsNativeWindowBorder
 
 		String subKey = "SOFTWARE\\Microsoft\\Windows\\DWM";
 
-		int value = RegGetDword( HKEY_CURRENT_USER, subKey, "ColorPrevalence" );
+		int value = registryGetIntValue( subKey, "ColorPrevalence", -1 );
 		colorizationColorAffectsBorders = (value > 0);
 
-		value = RegGetDword( HKEY_CURRENT_USER, subKey, "ColorizationColor" );
+		value = registryGetIntValue( subKey, "ColorizationColor", -1 );
 		colorizationColor = (value != -1) ? new Color( value ) : null;
 
-		colorizationColorBalance = RegGetDword( HKEY_CURRENT_USER, subKey, "ColorizationColorBalance" );
+		colorizationColorBalance = registryGetIntValue( subKey, "ColorizationColorBalance", -1 );
 	}
 
-	private static int RegGetDword( HKEY hkey, String lpSubKey, String lpValue ) {
+	private static int registryGetIntValue( String key, String valueName, int defaultValue ) {
 		try {
-			return Advapi32Util.registryGetIntValue( hkey, lpSubKey, lpValue );
+			return Advapi32Util.registryGetIntValue( HKEY_CURRENT_USER, key, valueName );
 		} catch( RuntimeException ex ) {
-			return -1;
+			return defaultValue;
 		}
 	}
 

flatlaf-natives/flatlaf-natives-windows/README.md

@@ -0,0 +1,17 @@
+FlatLaf Windows 10 Native Library
+=================================
+
+This sub-project contains the source code for the FlatLaf Windows 10 native
+library (DLL).
+
+The native library can be built only on Windows and requires a C++ compiler.
+Tested only with Microsoft Visual C++ 2019 (comes with Visual Studio 2019).
+
+To be able to build FlatLaf on any platform, and without C++ compiler, the
+pre-built DLL is checked into Git at
+`flatlaf-core/src/main/resources/com/formdev/flatlaf/natives/flatlaf-windows-x86_64.dll`.
+
+This DLL was built on a GitHub server with the help of GitHub Actions. See:
+[Native Libraries](https://github.com/JFormDesigner/FlatLaf/actions/workflows/natives.yml)
+workflow. Then the produced Artifacts ZIP was downloaded and the DLL checked
+into Git.

flatlaf-natives/flatlaf-natives-windows/build.gradle.kts

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+	id( "dev.nokee.jni-library" ) version "0.4.0"
+	id( "dev.nokee.cpp-language" ) version "0.4.0"
+}
+
+library {
+	targetMachines.set( listOf( machines.windows.x86_64 ) )
+
+	variants.configureEach {
+		// depend on :flatlaf-core:compileJava because this task generates the JNI headers
+		tasks.named( "compileCpp" ) {
+			dependsOn( ":flatlaf-core:compileJava" )
+		}
+
+		sharedLibrary {
+			compileTasks.configureEach {
+				onlyIf { isBuildable }
+
+				doFirst {
+					println( "Used Tool Chain:" )
+					println( "  - ${toolChain.get()}" )
+					println( "Available Tool Chains:" )
+					toolChains.forEach {
+						println( "  - $it" )
+					}
+
+					// copy needed JNI headers
+					copy {
+						from( project( ":flatlaf-core" ).buildDir.resolve( "generated/jni-headers" ) )
+						into( "src/main/headers" )
+						include(
+							"com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder.h",
+							"com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc.h"
+						)
+						filter<org.apache.tools.ant.filters.FixCrLfFilter>(
+							"eol" to org.apache.tools.ant.filters.FixCrLfFilter.CrLf.newInstance( "lf" )
+						)
+					}
+				}
+
+				compilerArgs.addAll( toolChain.map {
+					when( it ) {
+						is Gcc, is Clang -> listOf( "-O2" )
+						is VisualCpp -> listOf( "/O2", "/Zl", "/GS-" )
+						else -> emptyList()
+					}
+				} )
+			}
+
+			linkTask.configure {
+				onlyIf { isBuildable }
+
+				val nativesDir = project( ":flatlaf-core" ).projectDir.resolve( "src/main/resources/com/formdev/flatlaf/natives" )
+				val libraryName = "flatlaf-windows-x86_64.dll"
+
+				outputs.file( "$nativesDir/$libraryName" )
+
+				val jawt = "${org.gradle.internal.jvm.Jvm.current().javaHome}/lib/jawt"
+				linkerArgs.addAll( toolChain.map {
+					when( it ) {
+						is Gcc, is Clang -> listOf( "-l${jawt}", "-lUser32", "-lshell32", "-lAdvAPI32", "-lKernel32" )
+						is VisualCpp -> listOf( "${jawt}.lib", "User32.lib", "shell32.lib", "AdvAPI32.lib", "Kernel32.lib", "/NODEFAULTLIB" )
+						else -> emptyList()
+					}
+				} )
+
+				doLast {
+					// copy shared library to flatlaf-core resources
+					copy {
+						from( linkedFile )
+						into( nativesDir )
+						rename( "flatlaf-natives-windows.dll", libraryName )
+					}
+				}
+			}
+
+			tasks.named( "jar" ) {
+				onlyIf { false }
+			}
+		}
+	}
+}

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/FlatWndProc.cpp

@@ -0,0 +1,409 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// avoid inlining of printf()
+#define _NO_CRT_STDIO_INLINE
+
+#include <windows.h>
+#include <windowsx.h>
+#include <shellapi.h>
+#include <jawt.h>
+#include <jawt_md.h>
+#include "FlatWndProc.h"
+#include "com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc.h"
+
+/**
+ * @author Karl Tauber
+ */
+
+//---- JNI methods ------------------------------------------------------------
+
+extern "C"
+JNIEXPORT jlong JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_00024WndProc_installImpl
+	( JNIEnv *env, jobject obj, jobject window )
+{
+	return reinterpret_cast<jlong>( FlatWndProc::install( env, obj, window ) );
+}
+
+extern "C"
+JNIEXPORT void JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_00024WndProc_uninstallImpl
+	( JNIEnv* env, jobject obj, jlong hwnd )
+{
+	FlatWndProc::uninstall( env, obj, reinterpret_cast<HWND>( hwnd ) );
+}
+
+//---- class FlatWndProc fields -----------------------------------------------
+
+int FlatWndProc::initialized = 0;
+jmethodID FlatWndProc::onNcHitTestMID;
+jmethodID FlatWndProc::isFullscreenMID;
+jmethodID FlatWndProc::fireStateChangedLaterOnceMID;
+
+HWNDMap* FlatWndProc::hwndMap;
+
+//---- class FlatWndProc methods ----------------------------------------------
+
+FlatWndProc::FlatWndProc() {
+	jvm = NULL;
+	env = NULL;
+	obj = NULL;
+	hwnd = NULL;
+	defaultWndProc = NULL;
+}
+
+HWND FlatWndProc::install( JNIEnv *env, jobject obj, jobject window ) {
+	initIDs( env, obj );
+
+	if( initialized < 0 )
+		return 0;
+
+	// create HWND map
+	if( hwndMap == NULL )
+		hwndMap = new HWNDMap();
+
+	// get window handle
+	HWND hwnd = getWindowHandle( env, window );
+	if( hwnd == NULL || hwndMap->get( hwnd ) != NULL )
+		return 0;
+
+	FlatWndProc* fwp = new FlatWndProc();
+	env->GetJavaVM( &fwp->jvm );
+	fwp->obj = env->NewGlobalRef( obj );
+	fwp->hwnd = hwnd;
+	hwndMap->put( hwnd, fwp );
+
+	// replace window procedure
+	fwp->defaultWndProc = reinterpret_cast<WNDPROC>(
+		::SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR) FlatWndProc::StaticWindowProc ) );
+
+	// remove the OS window title bar
+	fwp->updateFrame();
+
+	return hwnd;
+}
+
+void FlatWndProc::uninstall( JNIEnv *env, jobject obj, HWND hwnd ) {
+	if( hwnd == NULL )
+		return;
+
+	FlatWndProc* fwp = (FlatWndProc*) hwndMap->get( hwnd );
+	if( fwp == NULL )
+		return;
+
+	hwndMap->remove( hwnd );
+
+	// restore original window procedure
+	::SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR) fwp->defaultWndProc );
+
+	// show the OS window title bar
+	fwp->updateFrame();
+
+	// cleanup
+	env->DeleteGlobalRef( fwp->obj );
+	delete fwp;
+}
+
+void FlatWndProc::initIDs( JNIEnv *env, jobject obj ) {
+	if( initialized )
+		return;
+
+	initialized = -1;
+
+	jclass cls = env->GetObjectClass( obj );
+	onNcHitTestMID = env->GetMethodID( cls, "onNcHitTest", "(IIZ)I" );
+	isFullscreenMID = env->GetMethodID( cls, "isFullscreen", "()Z" );
+	fireStateChangedLaterOnceMID = env->GetMethodID( cls, "fireStateChangedLaterOnce", "()V" );
+
+	// check whether all IDs were found
+	if( onNcHitTestMID != NULL &&
+		isFullscreenMID != NULL &&
+		fireStateChangedLaterOnceMID != NULL )
+	  initialized = 1;
+}
+
+void FlatWndProc::updateFrame() {
+	// this sends WM_NCCALCSIZE and removes/shows the window title bar
+	::SetWindowPos( hwnd, hwnd, 0, 0, 0, 0,
+		SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER );
+}
+
+LRESULT CALLBACK FlatWndProc::StaticWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
+	FlatWndProc* fwp = (FlatWndProc*) hwndMap->get( hwnd );
+	return fwp->WindowProc( hwnd, uMsg, wParam, lParam );
+}
+
+/**
+ * NOTE: This method is invoked on the AWT-Windows thread (not the AWT-EventQueue thread).
+ */
+LRESULT CALLBACK FlatWndProc::WindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
+	switch( uMsg ) {
+		case WM_NCCALCSIZE:
+			return WmNcCalcSize( hwnd, uMsg, wParam, lParam );
+
+		case WM_NCHITTEST:
+			return WmNcHitTest( hwnd, uMsg, wParam, lParam );
+
+		case WM_NCRBUTTONUP:
+			if( wParam == HTCAPTION || wParam == HTSYSMENU )
+				openSystemMenu( hwnd, GET_X_LPARAM( lParam ), GET_Y_LPARAM( lParam ) );
+			break;
+
+		case WM_DWMCOLORIZATIONCOLORCHANGED:
+			fireStateChangedLaterOnce();
+			break;
+
+		case WM_DESTROY:
+			return WmDestroy( hwnd, uMsg, wParam, lParam );
+	}
+
+	return ::CallWindowProc( defaultWndProc, hwnd, uMsg, wParam, lParam );
+}
+/**
+ * Handle WM_DESTROY
+ *
+ * https://docs.microsoft.com/en-us/windows/win32/winmsg/wm-destroy
+ */
+LRESULT FlatWndProc::WmDestroy( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam ) {
+	// restore original window procedure
+	::SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR) defaultWndProc );
+
+	WNDPROC defaultWndProc2 = defaultWndProc;
+
+	// cleanup
+	getEnv()->DeleteGlobalRef( obj );
+	hwndMap->remove( hwnd );
+	delete this;
+
+	// call original AWT window procedure because it may fire window closed event in AwtWindow::WmDestroy()
+	return ::CallWindowProc( defaultWndProc2, hwnd, uMsg, wParam, lParam );
+}
+
+/**
+ * Handle WM_NCCALCSIZE
+ *
+ * https://docs.microsoft.com/en-us/windows/win32/winmsg/wm-nccalcsize
+ *
+ * See also NonClientIslandWindow::_OnNcCalcSize() here:
+ * https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp
+ */
+LRESULT FlatWndProc::WmNcCalcSize( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam ) {
+	if( wParam != TRUE )
+		return ::CallWindowProc( defaultWndProc, hwnd, uMsg, wParam, lParam );
+
+	NCCALCSIZE_PARAMS* params = reinterpret_cast<NCCALCSIZE_PARAMS*>( lParam );
+
+	// store the original top before the default window proc applies the default frame
+	int originalTop = params->rgrc[0].top;
+
+	// apply the default frame
+	LRESULT lResult = ::CallWindowProc( defaultWndProc, hwnd, uMsg, wParam, lParam );
+	if( lResult != 0 )
+		return lResult;
+
+	// re-apply the original top from before the size of the default frame was applied
+	params->rgrc[0].top = originalTop;
+
+	bool isMaximized = ::IsZoomed( hwnd );
+	if( isMaximized && !isFullscreen() ) {
+		// When a window is maximized, its size is actually a little bit more
+		// than the monitor's work area. The window is positioned and sized in
+		// such a way that the resize handles are outside of the monitor and
+		// then the window is clipped to the monitor so that the resize handle
+		// do not appear because you don't need them (because you can't resize
+		// a window when it's maximized unless you restore it).
+		params->rgrc[0].top += getResizeHandleHeight();
+
+		// check whether taskbar is in the autohide state
+		APPBARDATA autohide{ 0 };
+		autohide.cbSize = sizeof( autohide );
+		UINT state = (UINT) ::SHAppBarMessage( ABM_GETSTATE, &autohide );
+		if( (state & ABS_AUTOHIDE) != 0 ) {
+			// get monitor info
+			// (using MONITOR_DEFAULTTONEAREST finds right monitor when restoring from minimized)
+			HMONITOR hMonitor = ::MonitorFromWindow( hwnd, MONITOR_DEFAULTTONEAREST );
+			MONITORINFO monitorInfo{ 0 };
+			::GetMonitorInfo( hMonitor, &monitorInfo );
+
+			// If there's a taskbar on any side of the monitor, reduce our size
+			// a little bit on that edge.
+			if( hasAutohideTaskbar( ABE_TOP, monitorInfo.rcMonitor ) )
+				params->rgrc[0].top++;
+			if( hasAutohideTaskbar( ABE_BOTTOM, monitorInfo.rcMonitor ) )
+				params->rgrc[0].bottom--;
+			if( hasAutohideTaskbar( ABE_LEFT, monitorInfo.rcMonitor ) )
+				params->rgrc[0].left++;
+			if( hasAutohideTaskbar( ABE_RIGHT, monitorInfo.rcMonitor ) )
+				params->rgrc[0].right--;
+		}
+	}
+
+	return lResult;
+}
+
+/**
+ * Handle WM_NCHITTEST
+ *
+ * https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-nchittest
+ *
+ * See also NonClientIslandWindow::_OnNcHitTest() here:
+ * https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp
+ */
+LRESULT FlatWndProc::WmNcHitTest( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam ) {
+	// this will handle the left, right and bottom parts of the frame because we didn't change them
+	LRESULT lResult = ::CallWindowProc( defaultWndProc, hwnd, uMsg, wParam, lParam );
+	if( lResult != HTCLIENT )
+		return lResult;
+
+	// get window rectangle needed to convert mouse x/y from screen to window coordinates
+	RECT rcWindow;
+	::GetWindowRect( hwnd, &rcWindow );
+
+	// get mouse x/y in window coordinates
+	int x = GET_X_LPARAM( lParam ) - rcWindow.left;
+	int y = GET_Y_LPARAM( lParam ) - rcWindow.top;
+
+	int resizeBorderHeight = getResizeHandleHeight();
+	bool isOnResizeBorder = (y < resizeBorderHeight) &&
+		(::GetWindowLong( hwnd, GWL_STYLE ) & WS_THICKFRAME) != 0;
+
+	return onNcHitTest( x, y, isOnResizeBorder );
+}
+
+/**
+ * Returns the height of the little space at the top of the window used to
+ * resize the window.
+ *
+ * See also NonClientIslandWindow::_GetResizeHandleHeight() here:
+ * https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp
+ */
+int FlatWndProc::getResizeHandleHeight() {
+	int dpi = ::GetDpiForWindow( hwnd );
+
+	// there isn't a SM_CYPADDEDBORDER for the Y axis
+	return ::GetSystemMetricsForDpi( SM_CXPADDEDBORDER, dpi )
+		 + ::GetSystemMetricsForDpi( SM_CYSIZEFRAME, dpi );
+}
+
+/**
+ * Returns whether there is an autohide taskbar on the given edge.
+ */
+bool FlatWndProc::hasAutohideTaskbar( UINT edge, RECT rcMonitor ) {
+	APPBARDATA data{ 0 };
+	data.cbSize = sizeof( data );
+	data.uEdge = edge;
+	data.rc = rcMonitor;
+	HWND hTaskbar = (HWND) ::SHAppBarMessage( ABM_GETAUTOHIDEBAREX, &data );
+	return hTaskbar != nullptr;
+}
+
+BOOL FlatWndProc::isFullscreen() {
+	JNIEnv* env = getEnv();
+	if( env == NULL )
+		return FALSE;
+
+	return env->CallBooleanMethod( obj, isFullscreenMID );
+}
+
+int FlatWndProc::onNcHitTest( int x, int y, boolean isOnResizeBorder ) {
+	JNIEnv* env = getEnv();
+	if( env == NULL )
+		return isOnResizeBorder ? HTTOP : HTCLIENT;
+
+	return env->CallIntMethod( obj, onNcHitTestMID, (jint) x, (jint) y, (jboolean) isOnResizeBorder );
+}
+
+void FlatWndProc::fireStateChangedLaterOnce() {
+	JNIEnv* env = getEnv();
+	if( env == NULL )
+		return;
+
+	env->CallVoidMethod( obj, fireStateChangedLaterOnceMID );
+}
+
+// similar to JNU_GetEnv() in jni_util.c
+JNIEnv* FlatWndProc::getEnv() {
+	if( env != NULL )
+		return env;
+
+	jvm->GetEnv( (void **) &env, JNI_VERSION_1_2 );
+	return env;
+}
+
+/**
+ * Opens the window's system menu.
+ * The system menu is the menu that opens when the user presses Alt+Space or
+ * right clicks on the title bar
+ */
+void FlatWndProc::openSystemMenu( HWND hwnd, int x, int y ) {
+	// get system menu
+	HMENU systemMenu = ::GetSystemMenu( hwnd, false );
+
+	// update system menu
+	LONG style = ::GetWindowLong( hwnd, GWL_STYLE );
+	bool isMaximized = ::IsZoomed( hwnd );
+	setMenuItemState( systemMenu, SC_RESTORE, isMaximized );
+	setMenuItemState( systemMenu, SC_MOVE, !isMaximized );
+	setMenuItemState( systemMenu, SC_SIZE, (style & WS_THICKFRAME) != 0 && !isMaximized );
+	setMenuItemState( systemMenu, SC_MINIMIZE, (style & WS_MINIMIZEBOX) != 0 );
+	setMenuItemState( systemMenu, SC_MAXIMIZE, (style & WS_MAXIMIZEBOX) != 0 && !isMaximized );
+	setMenuItemState( systemMenu, SC_CLOSE, true );
+
+	// make "Close" item the default to be consistent with the system menu shown
+	// when pressing Alt+Space
+	::SetMenuDefaultItem( systemMenu, SC_CLOSE, 0 );
+
+	// show system menu
+	int ret = ::TrackPopupMenu( systemMenu, TPM_RETURNCMD, x, y, 0, hwnd, nullptr );
+	if( ret != 0 )
+		::PostMessage( hwnd, WM_SYSCOMMAND, ret, 0 );
+}
+
+void FlatWndProc::setMenuItemState( HMENU systemMenu, int item, bool enabled ) {
+	MENUITEMINFO mii{ 0 };
+	mii.cbSize = sizeof( mii );
+	mii.fMask = MIIM_STATE;
+	mii.fType = MFT_STRING;
+	mii.fState = enabled ? MF_ENABLED : MF_DISABLED;
+	::SetMenuItemInfo( systemMenu, item, FALSE, &mii );
+}
+
+HWND FlatWndProc::getWindowHandle( JNIEnv* env, jobject window ) {
+	JAWT awt;
+	awt.version = JAWT_VERSION_1_4;
+	if( !JAWT_GetAWT( env, &awt ) )
+		return 0;
+
+	jawt_DrawingSurface* ds = awt.GetDrawingSurface( env, window );
+	if( ds == NULL )
+		return 0;
+
+	jint lock = ds->Lock( ds );
+	if( (lock & JAWT_LOCK_ERROR) != 0 ) {
+		awt.FreeDrawingSurface( ds );
+		return 0;
+	}
+
+	JAWT_DrawingSurfaceInfo* dsi = ds->GetDrawingSurfaceInfo( ds );
+	JAWT_Win32DrawingSurfaceInfo* wdsi = (JAWT_Win32DrawingSurfaceInfo*) dsi->platformInfo;
+
+	HWND hwnd = wdsi->hwnd;
+
+	ds->FreeDrawingSurfaceInfo( dsi );
+	ds->Unlock( ds );
+	awt.FreeDrawingSurface( ds );
+
+	return hwnd;
+}

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/FlatWndProc.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <windows.h>
+#include "HWNDMap.h"
+
+/**
+ * @author Karl Tauber
+ */
+class FlatWndProc
+{
+public:
+	static HWND install( JNIEnv *env, jobject obj, jobject window );
+	static void uninstall( JNIEnv *env, jobject obj, HWND hwnd );
+
+private:
+	static int initialized;
+	static jmethodID onNcHitTestMID;
+	static jmethodID isFullscreenMID;
+	static jmethodID fireStateChangedLaterOnceMID;
+
+	static HWNDMap* hwndMap;
+
+	JavaVM* jvm;
+	JNIEnv* env; // attached to AWT-Windows/Win32 thread
+	jobject obj;
+	HWND hwnd;
+	WNDPROC defaultWndProc;
+
+	FlatWndProc();
+	static void initIDs( JNIEnv *env, jobject obj );
+	void updateFrame();
+
+	static LRESULT CALLBACK StaticWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
+	LRESULT CALLBACK WindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
+	LRESULT WmDestroy( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam );
+	LRESULT WmNcCalcSize( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam );
+	LRESULT WmNcHitTest( HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam );
+
+	int getResizeHandleHeight();
+	bool hasAutohideTaskbar( UINT edge, RECT rcMonitor );
+	BOOL isFullscreen();
+	int onNcHitTest( int x, int y, boolean isOnResizeBorder );
+	void fireStateChangedLaterOnce();
+	JNIEnv* getEnv();
+
+	void openSystemMenu( HWND hwnd, int x, int y );
+	void setMenuItemState( HMENU systemMenu, int item, bool enabled );
+
+	static HWND getWindowHandle( JNIEnv* env, jobject window );
+};

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/HWNDMap.cpp

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// avoid inlining of printf()
+#define _NO_CRT_STDIO_INLINE
+
+#include <stdio.h>
+#include "HWNDMap.h"
+
+#define DEFAULT_CAPACITY		20
+#define INCREASE_CAPACITY		10
+
+/**
+ * @author Karl Tauber
+ */
+
+class LOCK {
+	LPCRITICAL_SECTION lpCriticalSection;
+
+public:
+	LOCK( LPCRITICAL_SECTION lpCriticalSection ) {
+		this->lpCriticalSection = lpCriticalSection;
+		::EnterCriticalSection( lpCriticalSection );
+	}
+	~LOCK() {
+		::LeaveCriticalSection( lpCriticalSection );
+	}
+};
+
+
+HWNDMap::HWNDMap() {
+	size = 0;
+	capacity = DEFAULT_CAPACITY;
+	table = new Entry[capacity];
+
+	::InitializeCriticalSection( &criticalSection );
+
+//	dump( "<init>" );
+}
+
+LPVOID HWNDMap::get( HWND key ) {
+	LOCK lock( &criticalSection );
+
+	int index = binarySearch( key );
+	return (index >= 0) ? table[index].value : NULL;
+}
+
+void HWNDMap::put( HWND key, LPVOID value ) {
+	LOCK lock( &criticalSection );
+
+	int index = binarySearch( key );
+//	printf( "put %p %p = %d --\n", key, value, index );
+	if( index >= 0 ) {
+		// key already in map --> replace
+		table[index].value = value;
+	} else {
+		// insert new key
+		ensureCapacity( size + 1 );
+
+		// make roor for new entry
+		index = -(index + 1);
+		for( int i = size - 1; i >= index; i-- )
+			table[i + 1] = table[i];
+		size++;
+
+		// insert entry
+		table[index].key = key;
+		table[index].value = value;
+	}
+
+//	dump( "put" );
+}
+
+void HWNDMap::remove( HWND key ) {
+	LOCK lock( &criticalSection );
+
+	// search for key
+	int index = binarySearch( key );
+//	printf( "remove %p = %d --\n", key, index );
+	if( index < 0 )
+		return;
+
+	// remove entry
+	for( int i = index + 1; i < size; i++ )
+		table[i - 1] = table[i];
+	size--;
+
+//	dump( "remove" );
+}
+
+int HWNDMap::binarySearch( HWND key ) {
+	int low = 0;
+	int high = size - 1;
+
+	while( low <= high ) {
+		int mid = (low + high) >> 1;
+
+		HWND midKey = table[mid].key;
+		int cmp = midKey - key;
+		if( cmp < 0 )
+			low = mid + 1;
+		else if( cmp > 0 )
+			high = mid - 1;
+		else
+			return mid;
+	}
+
+	return -(low + 1);
+}
+
+void HWNDMap::ensureCapacity( int minCapacity ) {
+	if( minCapacity <= capacity )
+		return;
+
+	// allocate new table
+	int newCapacity = minCapacity + INCREASE_CAPACITY;
+	Entry* newTable = new Entry[newCapacity];
+
+	// copy old table to new table
+	for( int i = 0; i < capacity; i++ )
+		newTable[i] = table[i];
+
+	// delete old table
+	delete table;
+
+	table = newTable;
+	capacity = newCapacity;
+}
+
+/*
+void HWNDMap::dump( char* msg ) {
+	printf( "---- %s -----------------------\n", msg );
+	printf( "size     %d\n", size );
+	printf( "capacity %d\n", capacity );
+	printf( "table    %p\n", table );
+
+	for( int i = 0; i < capacity; i++ )
+		printf( "  %d: %p - %p  %s\n", i, table[i].key, table[i].value, i >= size ? "UNUSED" : "" );
+}
+*/

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/HWNDMap.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <windows.h>
+
+/**
+ * A simple map that uses a sorted array to store key/value pairs.
+ * 
+ * @author Karl Tauber
+ */
+
+struct Entry
+{
+	HWND key;
+	LPVOID value;
+};
+
+class HWNDMap
+{
+private:
+	int size; // used entries in table
+	int capacity; // total size of table
+	Entry* table;
+
+	// used to synchronize to make it thread safe
+	CRITICAL_SECTION criticalSection;
+
+public:
+	HWNDMap();
+
+	LPVOID get( HWND key );
+	void put( HWND key, LPVOID value );
+	void remove( HWND key );
+
+private:
+	int binarySearch( HWND key );
+	void ensureCapacity( int newCapacity );
+
+//	void dump( char* msg );
+};

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/Registry.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <windows.h>
+#include <winreg.h>
+#include <winerror.h>
+#include <jni.h>
+#include "com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder.h"
+
+/**
+ * @author Karl Tauber
+ */
+
+//---- JNI methods ------------------------------------------------------------
+
+extern "C"
+JNIEXPORT jint JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_registryGetIntValue
+	( JNIEnv* env, jclass cls, jstring key, jstring valueName, jint defaultValue )
+{
+	const char* skey = env->GetStringUTFChars( key, NULL );
+	const char* svalueName = env->GetStringUTFChars( valueName, NULL );
+
+	DWORD data = 0;
+	DWORD cbData = sizeof( data );
+	int rc = ::RegGetValueA( HKEY_CURRENT_USER, skey, svalueName, RRF_RT_DWORD, NULL, &data, &cbData );
+
+	env->ReleaseStringUTFChars( key, skey );
+	env->ReleaseStringUTFChars( valueName, svalueName );
+
+	return (rc == ERROR_SUCCESS) ? data : defaultValue;
+}

flatlaf-natives/flatlaf-natives-windows/src/main/cpp/Runtime.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// avoid inlining of printf()
+#define _NO_CRT_STDIO_INLINE
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+/**
+ * Methods that replace C-runtime methods and allow linking/running without C-runtime.
+ * 
+ * WARNING: Constructors/destructors of static objects are not invoked!
+ *
+ * https://documentation.help/Far-Manager/msdnmag-issues-01-01-hood-default.aspx.html
+ * www.catch22.net/tuts/win32/reducing-executable-size#the-c-runtime-and-default-libraries
+ * https://www.mvps.org/user32/nocrt.html
+ * 
+ * see also LIBCTINY on "Downloads" page here: http://www.wheaty.net/
+ * or https://github.com/leepa/libctiny
+ * 
+ * @author Karl Tauber
+ */
+
+extern "C"
+BOOL WINAPI _DllMainCRTStartup( HINSTANCE instance, DWORD reason, LPVOID reserved ) {
+	return TRUE;
+}
+
+void* __cdecl operator new( size_t cb ) {
+	return ::HeapAlloc( ::GetProcessHeap(), HEAP_ZERO_MEMORY, cb );
+}
+
+void* __cdecl operator new[]( size_t cb ) {
+	return ::HeapAlloc( ::GetProcessHeap(), HEAP_ZERO_MEMORY, cb );
+}
+
+void __cdecl operator delete( void* pv, size_t cb ) {
+	if( pv != NULL )
+		::HeapFree( ::GetProcessHeap(), 0, pv );
+}
+
+/*
+extern "C"
+int __cdecl printf( const char* format, ... ) {
+	char szBuff[1024];
+	int retValue;
+	DWORD cbWritten;
+	va_list argptr;
+
+	va_start( argptr, format );
+	retValue = wvsprintfA( szBuff, format, argptr );
+	va_end( argptr );
+
+	WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), szBuff, retValue, &cbWritten, NULL );
+
+	return retValue;
+}
+*/

flatlaf-natives/flatlaf-natives-windows/src/main/headers/com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder.h

@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder */
+
+#ifndef _Included_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder
+#define _Included_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder
+ * Method:    registryGetIntValue
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)I
+ */
+JNIEXPORT jint JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_registryGetIntValue
+  (JNIEnv *, jclass, jstring, jstring, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

flatlaf-natives/flatlaf-natives-windows/src/main/headers/com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc.h

@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc */
+
+#ifndef _Included_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc
+#define _Included_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTCLIENT
+#define com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTCLIENT 1L
+#undef com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTCAPTION
+#define com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTCAPTION 2L
+#undef com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTSYSMENU
+#define com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTSYSMENU 3L
+#undef com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTTOP
+#define com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc_HTTOP 12L
+/*
+ * Class:     com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc
+ * Method:    installImpl
+ * Signature: (Ljava/awt/Window;)J
+ */
+JNIEXPORT jlong JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_00024WndProc_installImpl
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_WndProc
+ * Method:    uninstallImpl
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_formdev_flatlaf_ui_FlatWindowsNativeWindowBorder_00024WndProc_uninstallImpl
+  (JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif