JavaFX: Adding JavaFX Support for NEWT utilizing native Window parenting via NewtCanvasJFX

NewtCanvasJFX, a JavaFX Canvas Node, allows attaching a native NEWT Window to the JavaFX Node's native Window (if attached).

The mechanism is similar to NewtCanvasAWT.

Current implementation supports placing the NEWT Window
into the JavaFX scene of the native window correctly,
as well as the following different lifecycles
- attach NewtCanvasJFX to already visible group->scene->window
- attach NewtCanvasJFX to not yet visible or attached group->scene->window
- attach NEWT Window before or after NewtCanvasJFX's visibility

The above is covered by unit test: TestNewtCanvasJFXGLn

This is the initial commit for JavaFX support and has been tested on
- OpenJDK 8 + OpenJFX 8
- GNU/Linux X11

1 files changed, 637 insertions, 0 deletions

diff --git a/src/newt/classes/com/jogamp/newt/javafx/NewtCanvasJFX.java b/src/newt/classes/com/jogamp/newt/javafx/NewtCanvasJFX.java
new file mode 100644
index 000000000..1fe3fa9ba
--- /dev/null
+++ b/src/newt/classes/com/jogamp/newt/javafx/NewtCanvasJFX.java
@@ -0,0 +1,637 @@
+/**
+ * Copyright 2019 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.newt.javafx;
+
+import com.jogamp.nativewindow.AbstractGraphicsConfiguration;
+import com.jogamp.nativewindow.AbstractGraphicsScreen;
+import com.jogamp.nativewindow.Capabilities;
+import com.jogamp.nativewindow.CapabilitiesImmutable;
+import com.jogamp.nativewindow.GraphicsConfigurationFactory;
+import com.jogamp.nativewindow.NativeSurface;
+import com.jogamp.nativewindow.NativeWindow;
+import com.jogamp.nativewindow.NativeWindowException;
+import com.jogamp.nativewindow.NativeWindowFactory;
+import com.jogamp.nativewindow.SurfaceUpdatedListener;
+import com.jogamp.nativewindow.WindowClosingProtocol;
+import com.jogamp.nativewindow.util.Insets;
+import com.jogamp.nativewindow.util.InsetsImmutable;
+import com.jogamp.nativewindow.util.Point;
+import com.jogamp.nativewindow.util.Rectangle;
+import com.jogamp.opengl.GLCapabilities;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.EventHandler;
+import javafx.geometry.Bounds;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import jogamp.newt.Debug;
+import jogamp.newt.javafx.JFXEDTUtil;
+
+import com.jogamp.nativewindow.javafx.JFXAccessor;
+import com.jogamp.newt.Display;
+import com.jogamp.newt.Window;
+import com.jogamp.newt.event.WindowEvent;
+import com.jogamp.newt.util.EDTUtil;
+
+/**
+ * JFX {@link Canvas} containing a NEWT {@link Window} using native parenting.
+ * <p>
+ * Implementation allows use of custom {@link GLCapabilities}.
+ * </p>
+ */
+public class NewtCanvasJFX extends Canvas implements WindowClosingProtocol {
+    private static final boolean DEBUG = Debug.debug("Window");
+
+    private volatile javafx.stage.Window parentWindow = null;
+    private volatile AbstractGraphicsScreen screen = null;
+
+    private WindowClosingMode newtChildCloseOp = WindowClosingMode.DISPOSE_ON_CLOSE;
+    private final Rectangle clientArea = new Rectangle();
+
+    private volatile JFXNativeWindow nativeWindow = null;
+    private volatile Window newtChild = null;
+    private volatile boolean newtChildReady = false; // ready if JFXEDTUtil is set and newtChild parented
+    private volatile boolean postSetSize = false; // pending resize
+    private volatile boolean postSetPos = false; // pending pos
+
+    private final EventHandler<javafx.stage.WindowEvent> windowClosingListener = new EventHandler<javafx.stage.WindowEvent>() {
+        public final void handle(final javafx.stage.WindowEvent e) {
+            if( DEBUG ) {
+                System.err.println("NewtCanvasJFX.Event.DISPOSE, "+e);
+            }
+            NewtCanvasJFX.this.dispose();
+        } };
+    private final EventHandler<javafx.stage.WindowEvent> windowShownListener = new EventHandler<javafx.stage.WindowEvent>() {
+        public final void handle(final javafx.stage.WindowEvent e) {
+            if( DEBUG ) {
+                System.err.println("NewtCanvasJFX.Event.SHOWN, "+e);
+            }
+            repaintAction(true);
+        } };
+
+    /**
+     * Instantiates a NewtCanvas with a NEWT child.
+     *
+     * <p>
+     * Note: The NEWT child {@link Display}'s {@link EDTUtil} is being set to an JFX conform implementation
+     *       via {@link Display#setEDTUtil(EDTUtil)}.
+     * </p>
+     * @param child optional preassigned {@link #Window}, maybe null
+     */
+    public NewtCanvasJFX(final Window child) {
+        super();
+
+        updateParentWindowAndScreen();
+
+        this.widthProperty().addListener(new ChangeListener<Number>() {
+            @Override public void changed(final ObservableValue<? extends Number> observable, final Number oldValue, final Number newValue) {
+                if( DEBUG ) {
+                    System.err.println("NewtCanvasJFX.Event.Width, "+oldValue.doubleValue()+" -> "+newValue.doubleValue()+", has "+getWidth());
+                }
+                updateSizeCheck(newValue.intValue(), (int)getHeight());
+                repaintAction(isVisible());
+            }
+        });
+        this.heightProperty().addListener(new ChangeListener<Number>() {
+            @Override public void changed(final ObservableValue<? extends Number> observable, final Number oldValue, final Number newValue) {
+                if( DEBUG ) {
+                    System.err.println("NewtCanvasJFX.Event.Height, "+oldValue.doubleValue()+" -> "+newValue.doubleValue()+", has "+getHeight());
+                }
+                updateSizeCheck((int)getWidth(), newValue.intValue());
+                repaintAction(isVisible());
+            }
+        });
+        this.visibleProperty().addListener(new ChangeListener<Boolean>() {
+            @Override public void changed(final ObservableValue<? extends Boolean> observable, final Boolean oldValue, final Boolean newValue) {
+                if( DEBUG ) {
+                    System.err.println("NewtCanvasJFX.Event.Visible, "+oldValue.booleanValue()+" -> "+newValue.booleanValue()+", has "+isVisible());
+                }
+                repaintAction(newValue.booleanValue());
+            }
+        });
+        this.sceneProperty().addListener(new ChangeListener<Scene>() {
+            @Override public void changed(final ObservableValue<? extends Scene> observable, final Scene oldValue, final Scene newValue) {
+                if( DEBUG ) {
+                    System.err.println("NewtCanvasJFX.Event.Scene, "+oldValue+" -> "+newValue+", has "+getScene());
+                    if(null != newValue) {
+                        final javafx.stage.Window w = newValue.getWindow();
+                        System.err.println("NewtCanvasJFX.Event.Scene window "+w+" (showing "+(null!=w?w.isShowing():0)+")");
+                    }
+                }
+                if( updateParentWindowAndScreen() ) {
+                    repaintAction(isVisible());
+                }
+            }
+        });
+
+        if(null != child) {
+            setNEWTChild(child);
+        }
+    }
+
+    private final void repaintAction(final boolean visible) {
+        if( visible && ( null != nativeWindow || validateNative(true /* completeReparent */) ) ) {
+            if( newtChildReady ) {
+                if( postSetSize ) {
+                    newtChild.setSize(clientArea.getWidth(), clientArea.getHeight());
+                    postSetSize = false;
+                }
+                if( postSetPos ) {
+                    newtChild.setPosition(clientArea.getX(), clientArea.getY());
+                    postSetPos = false;
+                }
+                newtChild.windowRepaint(0, 0, clientArea.getWidth(), clientArea.getHeight());
+            }
+        }
+    }
+
+    private final void updatePosSizeCheck() {
+        final Bounds b = localToScene(getBoundsInLocal());
+        updatePosCheck((int)b.getMinX(), (int)b.getMinY());
+        updateSizeCheck((int)getWidth(), (int)getHeight());
+    }
+    private final void updatePosCheck(final int newX, final int newY) {
+        final boolean posChanged;
+        {
+            final Rectangle oClientArea = clientArea;
+            posChanged = newX != oClientArea.getX() || newY != oClientArea.getY();
+            if( posChanged ) {
+                clientArea.setX(newX);
+                clientArea.setY(newY);
+            }
+        }
+        if(DEBUG) {
+            final long nsh = newtChildReady ? newtChild.getSurfaceHandle() : 0;
+            System.err.println("NewtCanvasJFX.updatePosCheck: posChanged "+posChanged+", ("+Thread.currentThread().getName()+"): newtChildReady "+newtChildReady+", "+clientArea.getX()+"/"+clientArea.getY()+" "+clientArea.getWidth()+"x"+clientArea.getHeight()+" - surfaceHandle 0x"+Long.toHexString(nsh));
+        }
+        if( posChanged ) {
+            if( newtChildReady ) {
+                newtChild.setPosition(clientArea.getX(), clientArea.getY());
+            } else {
+                postSetPos = true;
+            }
+        }
+    }
+    private final void updateSizeCheck(final int newWidth, final int newHeight) {
+        final boolean sizeChanged;
+        {
+            final Rectangle oClientArea = clientArea;
+            sizeChanged = newWidth != oClientArea.getWidth() || newHeight != oClientArea.getHeight();
+            if( sizeChanged ) {
+                clientArea.setWidth(newWidth);
+                clientArea.setHeight(newHeight);
+            }
+        }
+        if(DEBUG) {
+            final long nsh = newtChildReady ? newtChild.getSurfaceHandle() : 0;
+            System.err.println("NewtCanvasJFX.updateSizeCheck: sizeChanged "+sizeChanged+", ("+Thread.currentThread().getName()+"): newtChildReady "+newtChildReady+", "+clientArea.getX()+"/"+clientArea.getY()+" "+clientArea.getWidth()+"x"+clientArea.getHeight()+" - surfaceHandle 0x"+Long.toHexString(nsh));
+        }
+        if( sizeChanged ) {
+            if( newtChildReady ) {
+                newtChild.setSize(clientArea.getWidth(), clientArea.getHeight());
+            } else {
+                postSetSize = true;
+            }
+        }
+    }
+
+    private final ChangeListener<javafx.stage.Window> sceneWindowChangeListener = new ChangeListener<javafx.stage.Window>() {
+            @Override public void changed(final ObservableValue<? extends javafx.stage.Window> observable, final javafx.stage.Window oldValue, final javafx.stage.Window newValue) {
+                if( DEBUG ) {
+                    System.err.println("NewtCanvasJFX.Event.Window, "+oldValue+" -> "+newValue);
+                }
+                if( updateParentWindowAndScreen() ) {
+                    repaintAction(isVisible());
+                }
+            } };
+
+    private boolean updateParentWindowAndScreen() {
+        final Scene s = this.getScene();
+        if( null != s ) {
+            final javafx.stage.Window w = s.getWindow();
+            if( DEBUG ) {
+                System.err.println("NewtCanvasJFX.updateParentWindowAndScreen: Scene "+s+", Window "+w+" (showing "+(null!=w?w.isShowing():0)+")");
+            }
+            if( w != parentWindow ) {
+                disposeImpl(false);
+            }
+            parentWindow = w;
+            if( null != w ) {
+                screen = JFXAccessor.getScreen(JFXAccessor.getDevice(parentWindow), -1 /* default */);
+                parentWindow.addEventHandler(javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST, windowClosingListener);
+                parentWindow.addEventHandler(javafx.stage.WindowEvent.WINDOW_SHOWN, windowShownListener);
+                return true;
+            } else {
+                s.windowProperty().addListener(sceneWindowChangeListener);
+            }
+        } else {
+            if( DEBUG ) {
+                System.err.println("NewtCanvasJFX.updateParentWindowAndScreen: Null Scene");
+            }
+            if( null != parentWindow ) {
+                disposeImpl(false);
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Destroys this resource:
+     * <ul>
+     *   <li> Make the NEWT Child invisible </li>
+     *   <li> Disconnects the NEWT Child from this Canvas NativeWindow, reparent to NULL </li>
+     *   <li> Issues <code>destroy()</code> on the NEWT Child</li>
+     *   <li> Remove reference to the NEWT Child</li>
+     * </ul>
+     * @see Window#destroy()
+     */
+    // FIXME JFX similar @Override
+    public void dispose() {
+        disposeImpl(true);
+    }
+    private void disposeImpl(final boolean disposeNewtChild) {
+        if(DEBUG) {
+            System.err.println("NewtCanvasJFX.dispose: (has parent "+(null!=parentWindow)+", hasNative "+(null!=nativeWindow)+",\n\t"+newtChild);
+        }
+        if( null != newtChild ) {
+            if(DEBUG) {
+                System.err.println("NewtCanvasJFX.dispose.1: EDTUtil cur "+newtChild.getScreen().getDisplay().getEDTUtil());
+            }
+            if( null != nativeWindow ) {
+                configureNewtChild(false);
+                newtChild.setVisible(false);
+                newtChild.reparentWindow(null, -1, -1, 0 /* hint */);
+            }
+            if( disposeNewtChild ) {
+                newtChild.destroy();
+                newtChild = null;
+            }
+        }
+        if( null != parentWindow ) {
+            parentWindow.getScene().windowProperty().removeListener(sceneWindowChangeListener);
+            parentWindow.removeEventHandler(javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST, windowClosingListener);
+            parentWindow.removeEventHandler(javafx.stage.WindowEvent.WINDOW_SHOWN, windowShownListener);
+            parentWindow = null;
+        }
+        if( null != screen ) {
+            screen.getDevice().close();
+            screen = null;
+        }
+        nativeWindow = null;
+    }
+
+    private final boolean validateNative(final boolean completeReparent) {
+        if( null == parentWindow ) {
+            return false;
+        }
+        assert null == nativeWindow;
+        updatePosSizeCheck();
+        if(0 >= clientArea.getWidth() || 0 >= clientArea.getHeight()) {
+            return false;
+        }
+        final long nativeWindowHandle = JFXAccessor.getWindowHandle(parentWindow);
+        if( 0 == nativeWindowHandle ) {
+            return false;
+        }
+        screen.getDevice().open();
+
+        /* Native handle for the control, used to associate with GLContext */
+        final int visualID = JFXAccessor.getNativeVisualID(screen.getDevice(), nativeWindowHandle);
+        final boolean visualIDValid = NativeWindowFactory.isNativeVisualIDValidForProcessing(visualID);
+        if(DEBUG) {
+            System.err.println("NewtCanvasJFX.validateNative() windowHandle 0x"+Long.toHexString(nativeWindowHandle)+", visualID 0x"+Integer.toHexString(visualID)+", valid "+visualIDValid);
+        }
+        if( visualIDValid ) {
+            /* Get the nativewindow-Graphics Device associated with this control (which is determined by the parent Composite).
+             * Note: JFX is owner of the native handle, hence no closing operation will be a NOP. */
+            final CapabilitiesImmutable caps = new Capabilities();
+            final GraphicsConfigurationFactory factory = GraphicsConfigurationFactory.getFactory(screen.getDevice(), caps);
+            final AbstractGraphicsConfiguration config = factory.chooseGraphicsConfiguration( caps, caps, null, screen, visualID );
+            if(DEBUG) {
+                System.err.println("NewtCanvasJFX.validateNative() factory: "+factory+", windowHandle 0x"+Long.toHexString(nativeWindowHandle)+", visualID 0x"+Integer.toHexString(visualID)+", chosen config: "+config);
+                // Thread.dumpStack();
+            }
+            if (null == config) {
+                throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this);
+            }
+
+            nativeWindow = new JFXNativeWindow(config, nativeWindowHandle);
+            if( completeReparent ) {
+                reparentWindow( true );
+            }
+        }
+
+        return null != nativeWindow;
+    }
+
+    /**
+     * Sets a new NEWT child, provoking reparenting.
+     * <p>
+     * A previously detached <code>newChild</code> will be released to top-level status
+     * and made invisible.
+     * </p>
+     * <p>
+     * Note: When switching NEWT child's, detaching the previous first via <code>setNEWTChild(null)</code>
+     * produced much cleaner visual results.
+     * </p>
+     * <p>
+     * Note: The NEWT child {@link Display}'s {@link EDTUtil} is being set to an JFX conform implementation
+     *       via {@link Display#setEDTUtil(EDTUtil)}.
+     * </p>
+     * @return the previous attached newt child.
+     */
+    public Window setNEWTChild(final Window newChild) {
+        final Window prevChild = newtChild;
+        if(DEBUG) {
+            System.err.println("NewtCanvasJFX.setNEWTChild.0: win "+newtWinHandleToHexString(prevChild)+" -> "+newtWinHandleToHexString(newChild));
+        }
+        // remove old one
+        if(null != newtChild) {
+            reparentWindow( false );
+            newtChild = null;
+        }
+        // add new one, reparent only if ready
+        newtChild = newChild;
+        if( null != newtChild && ( null != nativeWindow || validateNative(false /* completeReparent */) ) ) {
+            reparentWindow( true );
+        }
+        return prevChild;
+    }
+
+    private void reparentWindow(final boolean add) {
+        if( null == newtChild ) {
+            return; // nop
+        }
+        if(DEBUG) {
+            System.err.println("NewtCanvasJFX.reparentWindow.0: add="+add+", win "+newtWinHandleToHexString(newtChild)+", EDTUtil: cur "+newtChild.getScreen().getDisplay().getEDTUtil());
+        }
+
+        newtChild.setFocusAction(null); // no AWT focus traversal ..
+        if(add) {
+            assert null != nativeWindow && null != parentWindow;
+            updatePosSizeCheck();
+            final int x = clientArea.getX();
+            final int y = clientArea.getY();
+            final int w = clientArea.getWidth();
+            final int h = clientArea.getHeight();
+
+            // set JFX EDT and start it
+            if(false) {
+                final Display newtDisplay = newtChild.getScreen().getDisplay();
+                final EDTUtil edtUtil = new JFXEDTUtil(newtDisplay);
+                edtUtil.start();
+                newtDisplay.setEDTUtil( edtUtil );
+            }
+
+            newtChild.setSize(w, h);
+            newtChild.reparentWindow(nativeWindow, x, y, Window.REPARENT_HINT_BECOMES_VISIBLE);
+            newtChild.setPosition(x, y);
+            newtChild.setVisible(true);
+            configureNewtChild(true);
+            newtChild.sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED); // trigger a resize/relayout to listener
+
+            // force this JFX Canvas to be focus-able,
+            // since it is completely covered by the newtChild (z-order).
+            // FIXME ??? super.requestFocus();
+        } else {
+            configureNewtChild(false);
+            newtChild.setVisible(false);
+            newtChild.reparentWindow(null, -1, -1, 0 /* hints */);
+        }
+        if(DEBUG) {
+            System.err.println("NewtCanvasJFX.reparentWindow.X: add="+add+", win "+newtWinHandleToHexString(newtChild)+", EDTUtil: cur "+newtChild.getScreen().getDisplay().getEDTUtil());
+        }
+    }
+
+    private void configureNewtChild(final boolean attach) {
+        newtChildReady = attach;
+        if( null != newtChild ) {
+            newtChild.setKeyboardFocusHandler(null);
+            if(attach) {
+                newtChildCloseOp = newtChild.setDefaultCloseOperation(WindowClosingMode.DO_NOTHING_ON_CLOSE);
+            } else {
+                newtChild.setFocusAction(null);
+                newtChild.setDefaultCloseOperation(newtChildCloseOp);
+            }
+        }
+    }
+
+    /** @return the current NEWT child */
+    public Window getNEWTChild() {
+        return newtChild;
+    }
+
+    /** @return this JFX Canvas NativeWindow representation, may be null in case it has not been realized. */
+    public NativeWindow getNativeWindow() { return nativeWindow; }
+
+    @Override
+    public WindowClosingMode getDefaultCloseOperation() {
+        return newtChildCloseOp; // TODO: implement ?!
+    }
+
+    @Override
+    public WindowClosingMode setDefaultCloseOperation(final WindowClosingMode op) {
+        return newtChildCloseOp = op; // TODO: implement ?!
+    }
+
+
+    boolean isParent() {
+        return null!=newtChild ;
+    }
+
+    boolean isFullscreen() {
+        return null != newtChild && newtChild.isFullscreen();
+    }
+
+    private final void requestFocusNEWTChild() {
+        if( newtChildReady ) {
+            newtChild.setFocusAction(null);
+            newtChild.requestFocus();
+        }
+    }
+
+    @Override
+    public void requestFocus() {
+        NewtCanvasJFX.super.requestFocus();
+        requestFocusNEWTChild();
+    }
+
+    private class JFXNativeWindow implements NativeWindow {
+        private final AbstractGraphicsConfiguration config;
+        private final long nativeWindowHandle;
+        private final InsetsImmutable insets; // only required to allow proper client position calculation on OSX
+
+        public JFXNativeWindow(final AbstractGraphicsConfiguration config, final long nativeWindowHandle) {
+            this.config = config;
+            this.nativeWindowHandle = nativeWindowHandle;
+            this.insets = new Insets(0, 0, 0, 0);
+        }
+
+        @Override
+        public int lockSurface() throws NativeWindowException, RuntimeException {
+            return NativeSurface.LOCK_SUCCESS;
+        }
+
+        @Override
+        public void unlockSurface() { }
+
+        @Override
+        public boolean isSurfaceLockedByOtherThread() {
+            return false;
+        }
+
+        @Override
+        public Thread getSurfaceLockOwner() {
+            return null;
+        }
+
+        @Override
+        public boolean surfaceSwap() {
+            return false;
+        }
+
+        @Override
+        public void addSurfaceUpdatedListener(final SurfaceUpdatedListener l) { }
+
+        @Override
+        public void addSurfaceUpdatedListener(final int index, final SurfaceUpdatedListener l) throws IndexOutOfBoundsException {
+        }
+
+        @Override
+        public void removeSurfaceUpdatedListener(final SurfaceUpdatedListener l) { }
+
+        @Override
+        public long getSurfaceHandle() {
+            return 0;
+        }
+
+        @Override
+        public int getWidth() {
+            return getSurfaceWidth(); // FIXME: Use 'scale' or an actual window-width
+        }
+
+        @Override
+        public int getHeight() {
+            return getSurfaceHeight(); // FIXME: Use 'scale' or an actual window-width
+        }
+
+        @Override
+        public final int[] convertToWindowUnits(final int[] pixelUnitsAndResult) {
+            return pixelUnitsAndResult; // FIXME HiDPI: use 'pixelScale'
+        }
+
+        @Override
+        public final int[] convertToPixelUnits(final int[] windowUnitsAndResult) {
+            return windowUnitsAndResult; // FIXME HiDPI: use 'pixelScale'
+        }
+
+        @Override
+        public int getSurfaceWidth() {
+            return clientArea.getWidth();
+        }
+
+        @Override
+        public int getSurfaceHeight() {
+            return clientArea.getHeight();
+        }
+
+        @Override
+        public final NativeSurface getNativeSurface() { return this; }
+
+        @Override
+        public AbstractGraphicsConfiguration getGraphicsConfiguration() {
+            return config;
+        }
+
+        @Override
+        public long getDisplayHandle() {
+            return config.getScreen().getDevice().getHandle();
+        }
+
+        @Override
+        public int getScreenIndex() {
+            return config.getScreen().getIndex();
+        }
+
+        @Override
+        public void surfaceUpdated(final Object updater, final NativeSurface ns, final long when) { }
+
+        @Override
+        public void destroy() { }
+
+        @Override
+        public NativeWindow getParent() {
+            return null;
+        }
+
+        @Override
+        public long getWindowHandle() {
+            return nativeWindowHandle;
+        }
+
+        @Override
+        public InsetsImmutable getInsets() {
+            return insets;
+        }
+
+        @Override
+        public int getX() {
+            return 0;
+        }
+
+        @Override
+        public int getY() {
+            return 0;
+        }
+
+        @Override
+        public Point getLocationOnScreen(final Point point) {
+            final Point los = NativeWindowFactory.getLocationOnScreen(this); // client window location on screen
+            if(null!=point) {
+              return point.translate(los);
+            } else {
+              return los;
+            }
+        }
+
+        @Override
+        public boolean hasFocus() {
+            return isFocused();
+        }
+    };
+
+    static String newtWinHandleToHexString(final Window w) {
+        return null != w ? toHexString(w.getWindowHandle()) : "nil";
+    }
+    static String toHexString(final long l) {
+        return "0x"+Long.toHexString(l);
+    }
+}
+