Bug 741 HiDPI: Refine Monitor/Screen [virtual] Viewport Definition / Add NEWT Support / Fix JAWT getPixelScale deadlock

- NativeWindow/Surface/NEWT API DOC: Define Coordinate System of Window and Screen

- OSXUtil: Add getPixelScale(..) via Screen index and 'windowOrView'

- JAWTWindow/JAWTUtil.getPixelScale(..): Use pre-fetched AWT GraphicsConfiguration to solve AWT-TreeLock (deadlock)

- [Virtual] Viewport of MonitorDevice and Screen:
  - Properly calculate and expose [virtual] viewport in window and pixel units
    - OSX Monitor viewports in pixel units are 'reconstructed'
  - Window/Viewport to Monitor selection shall be perfomed via window units (unique)

- OSX NEWT Window create/init (native): Use given size and coordinates even in fullscreen mode
  Don't override by quering NSScreen coordinates, trust given values.

- Fix test cases, i.e. usage of pixel- and window-units

16 files changed, 340 insertions, 139 deletions

diff --git a/src/newt/classes/jogamp/newt/MonitorDeviceImpl.java b/src/newt/classes/jogamp/newt/MonitorDeviceImpl.java
index 9e10879c4..e9e41a0ef 100644
--- a/src/newt/classes/jogamp/newt/MonitorDeviceImpl.java
+++ b/src/newt/classes/jogamp/newt/MonitorDeviceImpl.java
@@ -38,8 +38,8 @@ import com.jogamp.newt.Screen;
 
 public class MonitorDeviceImpl extends MonitorDevice {
 
-    public MonitorDeviceImpl(ScreenImpl screen, int nativeId, DimensionImmutable sizeMM, Rectangle viewport, MonitorMode currentMode, ArrayHashSet<MonitorMode> supportedModes) {
-        super(screen, nativeId, sizeMM, viewport, currentMode, supportedModes);
+    public MonitorDeviceImpl(ScreenImpl screen, int nativeId, DimensionImmutable sizeMM, Rectangle viewportPU, Rectangle viewportWU, MonitorMode currentMode, ArrayHashSet<MonitorMode> supportedModes) {
+        super(screen, nativeId, sizeMM, viewportPU, viewportWU, currentMode, supportedModes);
     }
 
     @Override
@@ -136,11 +136,10 @@ public class MonitorDeviceImpl extends MonitorDevice {
         this.currentMode = currentMode;
     }
 
-    /* pp */ final void setViewportValue(Rectangle viewport) {
-        this.viewport = viewport;
-    }
+    /* pp */ final Rectangle getMutuableViewportPU() { return viewportPU; }
+    /* pp */ final Rectangle getMutuableViewportWU() { return viewportWU; }
 
-    /* pp */ ArrayHashSet<MonitorMode> getSupportedModesImpl() {
+    /* pp */ final ArrayHashSet<MonitorMode> getSupportedModesImpl() {
         return supportedModes;
     }
 
diff --git a/src/newt/classes/jogamp/newt/MonitorModeProps.java b/src/newt/classes/jogamp/newt/MonitorModeProps.java
index 9d8f4919c..55cbf77f3 100644
--- a/src/newt/classes/jogamp/newt/MonitorModeProps.java
+++ b/src/newt/classes/jogamp/newt/MonitorModeProps.java
@@ -81,9 +81,10 @@ public class MonitorModeProps {
                                                    ;
 
     /** WARNING: must be synchronized with ScreenMode.h, native implementation
-     * 10: count + id, ScreenSizeMM[width, height], rotated Viewport[x, y, width, height], currentMonitorModeId, rotation, supportedModeId+
+     * 15: count + id, ScreenSizeMM[width, height], rotated Viewport pixel-units, rotated viewport window-units, currentMonitorModeId, rotation, supportedModeId+
+     *     Viewport := [x, y, width, height] (4 elements)
      */
-    public static final int MIN_MONITOR_DEVICE_PROPERTIES = 11;
+    public static final int MIN_MONITOR_DEVICE_PROPERTIES = 15;
 
     public static final int IDX_MONITOR_DEVICE_VIEWPORT =   1 // count
                                                           + 1 // native mode
@@ -223,7 +224,8 @@ public class MonitorModeProps {
         final List<MonitorMode> allMonitorModes = cache.monitorModes.getData();
         final int id = monitorProperties[offset++];
         final DimensionImmutable sizeMM = streamInResolution(monitorProperties, offset); offset+=NUM_RESOLUTION_PROPERTIES;
-        final Rectangle viewport = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
+        final Rectangle viewportPU = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
+        final Rectangle viewportWU = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
         final MonitorMode currentMode;
         {
             final int modeId = monitorProperties[offset++];
@@ -240,7 +242,7 @@ public class MonitorModeProps {
                 }
             }
         }
-        MonitorDevice monitorDevice = new MonitorDeviceImpl(screen, id, sizeMM, viewport, currentMode, supportedModes);
+        MonitorDevice monitorDevice = new MonitorDeviceImpl(screen, id, sizeMM, viewportPU, viewportWU, currentMode, supportedModes);
         if(null!=cache) {
             monitorDevice = cache.monitorDevices.getOrAdd(monitorDevice);
         }
@@ -296,8 +298,9 @@ public class MonitorModeProps {
         offset++;
         final int id = monitorProperties[offset++];
         final DimensionImmutable sizeMM = streamInResolution(monitorProperties, offset); offset+=NUM_RESOLUTION_PROPERTIES;
-        final Rectangle viewport = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
-        MonitorDevice monitorDevice = new MonitorDeviceImpl(screen, id, sizeMM, viewport, currentMode, supportedModes);
+        final Rectangle viewportPU = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
+        final Rectangle viewportWU = new Rectangle(monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++], monitorProperties[offset++]);
+        MonitorDevice monitorDevice = new MonitorDeviceImpl(screen, id, sizeMM, viewportPU, viewportWU, currentMode, supportedModes);
         if(null!=cache) {
             monitorDevice = cache.monitorDevices.getOrAdd(monitorDevice);
         }
@@ -328,6 +331,10 @@ public class MonitorModeProps {
         data[idx++] = monitorDevice.getViewport().getY();
         data[idx++] = monitorDevice.getViewport().getWidth();
         data[idx++] = monitorDevice.getViewport().getHeight();
+        data[idx++] = monitorDevice.getViewportInWindowUnits().getX();
+        data[idx++] = monitorDevice.getViewportInWindowUnits().getY();
+        data[idx++] = monitorDevice.getViewportInWindowUnits().getWidth();
+        data[idx++] = monitorDevice.getViewportInWindowUnits().getHeight();
         data[idx++] = monitorDevice.getCurrentMode().getId();
         data[idx++] = monitorDevice.getCurrentMode().getRotation();
         final List<MonitorMode> supportedModes = monitorDevice.getSupportedModes();
diff --git a/src/newt/classes/jogamp/newt/ScreenImpl.java b/src/newt/classes/jogamp/newt/ScreenImpl.java
index d7e6c641c..949e7fa3b 100644
--- a/src/newt/classes/jogamp/newt/ScreenImpl.java
+++ b/src/newt/classes/jogamp/newt/ScreenImpl.java
@@ -81,10 +81,11 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
     protected int hashCode;
     protected AbstractGraphicsScreen aScreen;
     protected int refCount; // number of Screen references by Window
-    protected Rectangle vOriginSize = new Rectangle(0, 0, 0, 0); // virtual rotated screen origin and size
+    protected Rectangle virtViewportPU = new Rectangle(0, 0, 0, 0); // virtual rotated viewport in pixel units
+    protected Rectangle virtViewportWU = new Rectangle(0, 0, 0, 0); // virtual rotated viewport in window units
     protected static Dimension usrSize = null; // property values: newt.ws.swidth and newt.ws.sheight
     protected static volatile boolean usrSizeQueried = false;
-    private ArrayList<MonitorModeListener> refMonitorModeListener = new ArrayList<MonitorModeListener>();
+    private final ArrayList<MonitorModeListener> refMonitorModeListener = new ArrayList<MonitorModeListener>();
 
     private long tCreated; // creationTime
 
@@ -130,6 +131,7 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
                 screen.screen_idx = idx;
                 screen.fqname = display.getFQName()+"-s"+idx;
                 screen.hashCode = screen.fqname.hashCode();
+                screen.instantiationFinished();
                 Screen.addScreen2List(screen);
                 if(DEBUG) {
                     System.err.println("Screen.create() NEW: "+screen+" "+Display.getThreadName());
@@ -141,6 +143,14 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
         }
     }
 
+    /**
+     * Notifies the driver impl. that the instantiation is finished,
+     * ie. instance created and all fields set.
+     */
+    protected void instantiationFinished() {
+        // nop
+    }
+
     @Override
     public boolean equals(Object obj) {
         if (obj == null) {
@@ -260,19 +270,20 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
     protected abstract int validateScreenIndex(int idx);
 
     /**
-     * Stores the virtual origin and virtual <b>rotated</b> screen size.
+     * Calculates the virtual rotated viewport in pixel- and window units.
      * <p>
      * This method is called after the MonitorMode has been set or changed,
      * hence you may utilize it.
      * </p>
      * <p>
      * Default implementation uses the union of all monitor's viewport,
-     * calculated via {@link #unionOfMonitorViewportSize()}.
+     * calculated via {@link #unionOfMonitorViewportSize()}, however driver impl. may chose a different methodology.
      * </p>
-     * @param vOriginSize storage for result
+     * @param viewport storage for result in pixel units
+     * @param viewportInWindowUnits storage for result in window units
      */
-    protected void calcVirtualScreenOriginAndSize(final Rectangle vOriginSize) {
-        unionOfMonitorViewportSize(vOriginSize);
+    protected void calcVirtualScreenOriginAndSize(final Rectangle viewport, final Rectangle viewportInWindowUnits) {
+        unionOfMonitorViewports(viewport, viewportInWindowUnits);
     }
 
     @Override
@@ -281,18 +292,19 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
     }
 
     /**
-     * Updates the <b>rotated</b> virtual ScreenSize using the native impl.
+     * Updates the <b>rotated</b> virtual viewport, may use native impl.
      */
     protected void updateVirtualScreenOriginAndSize() {
         if(null != usrSize ) {
-            vOriginSize.set(0, 0, usrSize.getWidth(), usrSize.getHeight());
+            virtViewportPU.set(0, 0, usrSize.getWidth(), usrSize.getHeight());
+            virtViewportWU.set(0, 0, usrSize.getWidth(), usrSize.getHeight());
             if(DEBUG) {
-                System.err.println("Update user virtual screen viewport @ "+Thread.currentThread().getName()+": "+vOriginSize);
+                System.err.println("Update user virtual screen viewport @ "+Thread.currentThread().getName()+": "+virtViewportPU);
             }
         } else {
-            calcVirtualScreenOriginAndSize(vOriginSize);
+            calcVirtualScreenOriginAndSize(virtViewportPU, virtViewportWU);
             if(DEBUG) {
-                System.err.println("Updated virtual screen viewport @ "+Thread.currentThread().getName()+": "+vOriginSize);
+                System.err.println("Updated virtual screen viewport @ "+Thread.currentThread().getName()+": "+virtViewportPU+" [pixel], "+virtViewportWU+" [window]");
             }
         }
     }
@@ -318,19 +330,21 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
     }
 
     @Override
-    public final int getX() { return vOriginSize.getX(); }
+    public final int getX() { return virtViewportPU.getX(); }
     @Override
-    public final int getY() { return vOriginSize.getY(); }
+    public final int getY() { return virtViewportPU.getY(); }
     @Override
-    public final int getWidth() { return vOriginSize.getWidth(); }
+    public final int getWidth() { return virtViewportPU.getWidth(); }
     @Override
-    public final int getHeight() { return vOriginSize.getHeight(); }
+    public final int getHeight() { return virtViewportPU.getHeight(); }
     @Override
-    public final RectangleImmutable getViewport() { return vOriginSize; }
+    public final RectangleImmutable getViewport() { return virtViewportPU; }
+    @Override
+    public final RectangleImmutable getViewportInWindowUnits() { return virtViewportWU; }
 
     @Override
     public String toString() {
-        return "NEWT-Screen["+getFQName()+", idx "+screen_idx+", refCount "+refCount+", vsize "+vOriginSize+", "+aScreen+", "+display+
+        return "NEWT-Screen["+getFQName()+", idx "+screen_idx+", refCount "+refCount+", vsize "+virtViewportPU+" [pixels], "+virtViewportWU+" [window], "+aScreen+", "+display+
                             ", monitors: "+getMonitorDevices()+"]";
     }
 
@@ -357,7 +371,10 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
      */
     protected abstract void collectNativeMonitorModesAndDevicesImpl(MonitorModeProps.Cache cache);
 
-    protected Rectangle getNativeMonitorDeviceViewportImpl(MonitorDevice monitor) { return null; }
+    protected boolean updateNativeMonitorDeviceViewportImpl(final MonitorDevice monitor,
+                                                            final Rectangle viewportPU, final Rectangle viewportWU) {
+        return false;
+    }
 
     /**
      * To be implemented by the native specification.<br>
@@ -402,7 +419,7 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
             System.err.println("monitorModeChangeNotify @ "+Thread.currentThread().getName()+": "+me);
         }
         for(int i=0; i<refMonitorModeListener.size(); i++) {
-            ((MonitorModeListener)refMonitorModeListener.get(i)).monitorModeChangeNotify(me);
+            refMonitorModeListener.get(i).monitorModeChangeNotify(me);
         }
     }
 
@@ -410,12 +427,9 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
         final List<MonitorDevice> monitors = getMonitorDevices();
         for(int i=monitors.size()-1; i>=0; i--) {
             final MonitorDeviceImpl monitor = (MonitorDeviceImpl) monitors.get(i);
-            final Rectangle newViewport = getNativeMonitorDeviceViewportImpl(monitor);
+            final boolean viewportUpdated = updateNativeMonitorDeviceViewportImpl(monitor, monitor.getMutuableViewportPU(), monitor.getMutuableViewportWU());
             if( DEBUG ) {
-                System.err.println("Screen.updateMonitorViewport["+i+"] @  "+Thread.currentThread().getName()+": "+monitor.getViewport()+" -> "+newViewport);
-            }
-            if( null != newViewport ) {
-                monitor.setViewportValue(newViewport);
+                System.err.println("Screen.updateMonitorViewport["+i+"] @  "+Thread.currentThread().getName()+": updated: "+viewportUpdated+", PU "+monitor.getViewport()+", WU "+monitor.getViewportInWindowUnits());
             }
         }
     }
@@ -430,7 +444,7 @@ public abstract class ScreenImpl extends Screen implements MonitorModeListener {
             System.err.println("monitorModeChangeNotify @ "+Thread.currentThread().getName()+": success "+success+", "+me);
         }
         for(int i=0; i<refMonitorModeListener.size(); i++) {
-            ((MonitorModeListener)refMonitorModeListener.get(i)).monitorModeChanged(me, success);
+            refMonitorModeListener.get(i).monitorModeChanged(me, success);
         }
     }
 
diff --git a/src/newt/classes/jogamp/newt/WindowImpl.java b/src/newt/classes/jogamp/newt/WindowImpl.java
index 6a5fc5de0..08559c14d 100644
--- a/src/newt/classes/jogamp/newt/WindowImpl.java
+++ b/src/newt/classes/jogamp/newt/WindowImpl.java
@@ -910,9 +910,14 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return screen;
     }
 
+    protected void setScreen(ScreenImpl newScreen) { // never null !
+        removeScreenReference();
+        screen = newScreen;
+    }
+
     @Override
     public final MonitorDevice getMainMonitor() {
-        return screen.getMainMonitor( getSurfaceBounds() );
+        return screen.getMainMonitor( getBounds() );
     }
 
     /**
@@ -1072,7 +1077,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     @Override
     public final void setSurfaceSize(final int pixelWidth, final int pixelHeight) {
         // FIXME HiDPI: Shortcut, may need to adjust if we change scaling methodology
-        setSize(pixelWidth * getPixelScaleX(), pixelHeight * getPixelScaleY());
+        setSize(pixelWidth / getPixelScaleX(), pixelHeight / getPixelScaleY());
     }
     @Override
     public final void setTopLevelSize(final int width, final int height) {
@@ -1232,11 +1237,6 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
             return operation;
         }
 
-        private void setScreen(ScreenImpl newScreen) { // never null !
-            removeScreenReference();
-            screen = newScreen;
-        }
-
         @Override
         public final void run() {
             if( WindowImpl.this.isFullscreen() ) {
@@ -2249,8 +2249,8 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
 
                 int x,y,w,h;
 
-                final RectangleImmutable sviewport = screen.getViewportInWindowUnits(WindowImpl.this);
-                final RectangleImmutable viewport;
+                final RectangleImmutable sviewport = screen.getViewportInWindowUnits(); // window units
+                final RectangleImmutable viewport; // window units
                 final int fs_span_flag;
                 final boolean alwaysOnTopChange;
                 if(_fullscreen) {
@@ -2262,7 +2262,11 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
                             fullscreenMonitors = getScreen().getMonitorDevices();
                         }
                     }
-                    viewport = convertToWindowUnits(MonitorDevice.unionOfViewports(new Rectangle(), fullscreenMonitors));
+                    {
+                        final Rectangle viewportInWindowUnits = new Rectangle();
+                        MonitorDevice.unionOfViewports(null, viewportInWindowUnits, fullscreenMonitors);
+                        viewport = viewportInWindowUnits;
+                    }
                     if( isReconfigureFlagSupported(FLAG_IS_FULLSCREEN_SPAN) &&
                         ( fullscreenMonitors.size() > 1 || sviewport.compareTo(viewport) > 0 ) ) {
                         fs_span_flag = FLAG_IS_FULLSCREEN_SPAN;
@@ -2620,7 +2624,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     // Native MouseEvents pre-processed to be enqueued or consumed directly
     //
 
-    public void sendMouseEvent(final short eventType, final int modifiers,
+    public final void sendMouseEvent(final short eventType, final int modifiers,
                                final int x, final int y, final short button, final float rotation) {
         doMouseEvent(false, false, eventType, modifiers, x, y, button, MouseEvent.getRotationXYZ(rotation, modifiers), 1f);
     }
diff --git a/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
index 7a571318b..5671a05e4 100644
--- a/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
@@ -286,8 +286,7 @@ public class WindowDriver extends jogamp.newt.WindowImpl implements Callback2 {
 
         if( isFullscreen() ) {
             final MonitorDevice mainMonitor = getMainMonitor();
-            final RectangleImmutable screenRect = mainMonitor.getViewport();
-            final RectangleImmutable winRect = this.convertToWindowUnits((Rectangle)screenRect.cloneMutable());
+            final RectangleImmutable winRect = mainMonitor.getViewportInWindowUnits();
             definePosition(winRect.getX(), winRect.getY());
             defineSize(winRect.getWidth(), winRect.getHeight());
         }
diff --git a/src/newt/classes/jogamp/newt/driver/awt/AWTCanvas.java b/src/newt/classes/jogamp/newt/driver/awt/AWTCanvas.java
index f7722c91c..5dab64e39 100644
--- a/src/newt/classes/jogamp/newt/driver/awt/AWTCanvas.java
+++ b/src/newt/classes/jogamp/newt/driver/awt/AWTCanvas.java
@@ -65,7 +65,7 @@ public class AWTCanvas extends Canvas {
   private AWTGraphicsConfiguration awtConfig;
   private volatile JAWTWindow jawtWindow=null; // the JAWTWindow presentation of this AWT Canvas, bound to the 'drawable' lifecycle
   private CapabilitiesChooser chooser=null;
-  private CapabilitiesImmutable capabilities;
+  private final CapabilitiesImmutable capabilities;
 
   private boolean displayConfigChanged=false;
 
@@ -152,6 +152,10 @@ public class AWTCanvas extends Canvas {
     }
   }
 
+  public int getPixelScale() {
+    final JAWTWindow _jawtWindow = jawtWindow;
+    return (null != _jawtWindow) ? _jawtWindow.getPixelScale() : 1;
+  }
   public NativeWindow getNativeWindow() {
     final JAWTWindow _jawtWindow = jawtWindow;
     return (null != _jawtWindow) ? _jawtWindow : null;
diff --git a/src/newt/classes/jogamp/newt/driver/awt/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/awt/WindowDriver.java
index f99476851..1f0ba6f09 100644
--- a/src/newt/classes/jogamp/newt/driver/awt/WindowDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/awt/WindowDriver.java
@@ -99,6 +99,17 @@ public class WindowDriver extends WindowImpl {
     }
 
     @Override
+    protected final int getPixelScaleX() {
+        final AWTCanvas _awtCanvas = awtCanvas;
+        return null != _awtCanvas ? _awtCanvas.getPixelScale() : 1;
+    }
+
+    @Override
+    protected final int getPixelScaleY() {
+        return getPixelScaleX();
+    }
+
+    @Override
     protected void createNativeImpl() {
         if(0!=getParentWindowHandle()) {
             throw new RuntimeException("Window parenting not supported in AWT, use AWTWindow(Frame) cstr for wrapping instead");
diff --git a/src/newt/classes/jogamp/newt/driver/bcm/egl/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/bcm/egl/ScreenDriver.java
index d3231557f..64bc87a41 100644
--- a/src/newt/classes/jogamp/newt/driver/bcm/egl/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/bcm/egl/ScreenDriver.java
@@ -104,8 +104,8 @@ public class ScreenDriver extends jogamp.newt.ScreenImpl {
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(Rectangle vOriginSize) {
-        vOriginSize.set(0, 0, fixedWidth, fixedHeight); // FIXME
+    protected void calcVirtualScreenOriginAndSize(Rectangle viewport, Rectangle viewportInWindowUnits) {
+        viewport.set(0, 0, fixedWidth, fixedHeight); // FIXME
     }
 
     //----------------------------------------------------------------------
diff --git a/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/ScreenDriver.java
index dc2a8459a..e0228c10f 100644
--- a/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/ScreenDriver.java
@@ -97,8 +97,8 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(Rectangle vOriginSize) {
-        vOriginSize.set(0, 0, cachedWidth, cachedHeight);
+    protected void calcVirtualScreenOriginAndSize(Rectangle viewport, Rectangle viewportInWindowUnits) {
+        viewport.set(0, 0, cachedWidth, cachedHeight);
     }
 
     /** Called from {@link #initNative()}. */
diff --git a/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/WindowDriver.java
index 1c927acc4..188e5b964 100644
--- a/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/WindowDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/bcm/vc/iv/WindowDriver.java
@@ -170,13 +170,13 @@ public class WindowDriver extends WindowImpl {
     }
 
     @Override
-    public final void sendMouseEvent(final short eventType, final int modifiers,
-                                     final int x, final int y, final short button, final float rotation) {
+    protected final void doMouseEvent(final boolean enqueue, final boolean wait, final short eventType, final int modifiers,
+                                      final int x, final int y, final short button, final float[] rotationXYZ, final float rotationScale) {
         if( MouseEvent.EVENT_MOUSE_MOVED == eventType ) {
             final DisplayDriver display = (DisplayDriver) getScreen().getDisplay();
             display.moveActivePointerIcon(x, y);
         }
-        super.sendMouseEvent(eventType, modifiers, x, y, button, rotation);
+        super.doMouseEvent(enqueue, wait, eventType, modifiers, x, y, button, rotationXYZ, rotationScale);
     }
 
     @Override
diff --git a/src/newt/classes/jogamp/newt/driver/intel/gdl/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/intel/gdl/ScreenDriver.java
index 44802e348..20c60565a 100644
--- a/src/newt/classes/jogamp/newt/driver/intel/gdl/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/intel/gdl/ScreenDriver.java
@@ -106,8 +106,8 @@ public class ScreenDriver extends jogamp.newt.ScreenImpl {
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(Rectangle vOriginSize) {
-        vOriginSize.set(0, 0, cachedWidth, cachedHeight);
+    protected void calcVirtualScreenOriginAndSize(Rectangle viewport, Rectangle viewportInWindowUnits) {
+        viewport.set(0, 0, cachedWidth, cachedHeight);
     }
 
     //----------------------------------------------------------------------
diff --git a/src/newt/classes/jogamp/newt/driver/kd/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/kd/ScreenDriver.java
index 9ebe2629a..541576250 100644
--- a/src/newt/classes/jogamp/newt/driver/kd/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/kd/ScreenDriver.java
@@ -102,8 +102,8 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(Rectangle vOriginSize) {
-        vOriginSize.set(0, 0, cachedWidth, cachedHeight);
+    protected void calcVirtualScreenOriginAndSize(Rectangle viewport, Rectangle viewportInWindowUnits) {
+        viewport.set(0, 0, cachedWidth, cachedHeight);
     }
 
     protected void sizeChanged(int w, int h) {
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/macosx/ScreenDriver.java
index 4f3cc691b..5f458e2c9 100644
--- a/src/newt/classes/jogamp/newt/driver/macosx/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/macosx/ScreenDriver.java
@@ -35,13 +35,16 @@
 package jogamp.newt.driver.macosx;
 
 import javax.media.nativewindow.DefaultGraphicsScreen;
+import javax.media.nativewindow.util.Rectangle;
 
+import jogamp.nativewindow.macosx.OSXUtil;
 import jogamp.newt.MonitorModeProps;
 import jogamp.newt.ScreenImpl;
 
 import com.jogamp.common.util.ArrayHashSet;
 import com.jogamp.newt.MonitorDevice;
 import com.jogamp.newt.MonitorMode;
+import com.jogamp.opengl.math.FloatUtil;
 
 public class ScreenDriver extends ScreenImpl {
 
@@ -60,7 +63,7 @@ public class ScreenDriver extends ScreenImpl {
     @Override
     protected void closeNativeImpl() { }
 
-    private MonitorMode getMonitorModeImpl(MonitorModeProps.Cache cache, int crt_idx, int mode_idx) {
+    private MonitorMode getMonitorModeImpl(final MonitorModeProps.Cache cache, final int crt_idx, final int mode_idx) {
         final int[] modeProps = getMonitorMode0(crt_idx, mode_idx);
         final MonitorMode res;
         if (null == modeProps  || 0 >= modeProps.length) {
@@ -71,56 +74,133 @@ public class ScreenDriver extends ScreenImpl {
         return res;
     }
 
-    @Override
-    protected final void collectNativeMonitorModesAndDevicesImpl(MonitorModeProps.Cache cache) {
-        int crtIdx = 0;
-        int modeIdx = 0;
-        ArrayHashSet<MonitorMode> supportedModes = new ArrayHashSet<MonitorMode>();
-        do {
-            final MonitorMode mode = getMonitorModeImpl(cache, crtIdx, modeIdx);
-            if( null != mode ) {
-                supportedModes.getOrAdd(mode);
-                // next mode on same monitor
-                modeIdx++;
-            } else if( 0 < modeIdx ) {
-                // end of monitor modes - got at least one mode
-                final MonitorMode currentMode = getMonitorModeImpl(cache, crtIdx, -1);
-                if ( null == currentMode ) {
-                    throw new InternalError("Could not gather current mode of device "+crtIdx+", but gathered "+modeIdx+" modes");
+    private class CrtProps {
+        CrtProps() {
+            count = getMonitorCount0();
+            pixelScaleArray = new int[count];
+            propsOrigArray = new int[count][];
+            propsFixedArray = new int[count][];
+
+            //
+            // Gather whole topology of monitors (NSScreens)
+            //
+            for(int crtIdx=0; crtIdx<count; crtIdx++) {
+                final float pixelScaleRaw = (float) OSXUtil.GetPixelScale(crtIdx);
+                pixelScaleArray[crtIdx] = FloatUtil.isZero(pixelScaleRaw, FloatUtil.EPSILON) ? 1 : (int)pixelScaleRaw;
+                propsOrigArray[crtIdx] = getMonitorProps0(crtIdx);
+                if ( null == propsOrigArray[crtIdx] ) {
+                    throw new InternalError("Could not gather device props "+crtIdx+"/"+count);
                 }
-                final int[] monitorProps = getMonitorProps0(crtIdx);
-                if ( null == monitorProps ) {
-                    throw new InternalError("Could not gather device "+crtIdx+", but gathered "+modeIdx+" modes");
+                // copy orig -> fixed
+                final int propsLen = propsOrigArray[crtIdx].length;
+                propsFixedArray[crtIdx] = new int[propsLen];
+                System.arraycopy(propsOrigArray[crtIdx], 0, propsFixedArray[crtIdx], 0, propsLen);
+            }
+
+            //
+            // Fix scaled viewport w/ pixelScale of each monitorProps,
+            // i.e. size by its own pixelScale and x/y offset by querying it's neighbors.
+            //
+            for(int crtIdx=0; crtIdx<count; crtIdx++) {
+                final int[] thisMonitorProps = propsFixedArray[crtIdx];
+                final int x = thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+0];
+                final int y = thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+1];
+                final int thisPixelScale = pixelScaleArray[crtIdx];
+                thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+2] *= thisPixelScale; // fix width
+                thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+3] *= thisPixelScale; // fix height
+                if( 0 != x ) {
+                    // find matching viewport width for x-offset to apply it's pixelSize
+                    for(int i=0; i<count; i++) {
+                        if( i != crtIdx && x == propsOrigArray[i][MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+2] ) {
+                            thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+0] *= pixelScaleArray[i];
+                            break;
+                        }
+                    }
+                }
+                if( 0 != y ) {
+                    // find matching viewport height for y-offset to apply it's pixelSize
+                    for(int i=0; i<count; i++) {
+                        if( i != crtIdx && y == propsOrigArray[i][MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+3] ) {
+                            thisMonitorProps[MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT+1] *= pixelScaleArray[i];
+                            break;
+                        }
+                    }
                 }
-                // merge monitor-props + supported modes
-                MonitorModeProps.streamInMonitorDevice(null, cache, this, supportedModes, currentMode, monitorProps, 0);
-
-                // next monitor, 1st mode
-                supportedModes= new ArrayHashSet<MonitorMode>();
-                crtIdx++;
-                modeIdx=0;
-            } else {
-                // end of monitor
-                break;
             }
-        } while ( true );
+        }
+        final int count;
+        final int[] pixelScaleArray;
+        final int[][] propsOrigArray;
+        final int[][] propsFixedArray;
+    }
+
+    @Override
+    protected final void collectNativeMonitorModesAndDevicesImpl(final MonitorModeProps.Cache cache) {
+        final CrtProps crtProps = new CrtProps();
+
+        //
+        // Collect all monitorModes for all monitorDevices
+        //
+        for(int crtIdx=0; crtIdx<crtProps.count; crtIdx++) {
+            final ArrayHashSet<MonitorMode> supportedModes = new ArrayHashSet<MonitorMode>();
+            int modeIdx = 0;
+            {
+                // Get all supported modes for this monitorDevice
+                MonitorMode mode;
+                while( true ) {
+                    mode = getMonitorModeImpl(cache, crtIdx, modeIdx);
+                    if( null != mode ) {
+                        if( mode.getSurfaceSize().getBitsPerPixel() >= 24 ) { // drop otherwise
+                            supportedModes.getOrAdd(mode);
+                        }
+                        modeIdx++; // next mode on same monitor
+                    } else {
+                        break; // done with modes on this monitor
+                    }
+                }
+            }
+            if( 0 >= modeIdx ) {
+                throw new InternalError("Could not gather single mode of device "+crtIdx+"/"+crtProps.count);
+            }
+            final MonitorMode currentMode = getMonitorModeImpl(cache, crtIdx, -1);
+            if ( null == currentMode ) {
+                throw new InternalError("Could not gather current mode of device "+crtIdx+"/"+crtProps.count+", but gathered "+modeIdx+" modes");
+            }
+            // merge monitor-props + supported modes
+            MonitorModeProps.streamInMonitorDevice(null, cache, this, supportedModes, currentMode, crtProps.propsFixedArray[crtIdx], 0);
+        }
+    }
+
+    @Override
+    protected boolean updateNativeMonitorDeviceViewportImpl(final MonitorDevice monitor, final Rectangle viewportPU, final Rectangle viewportWU) {
+        final CrtProps crtProps = new CrtProps();
+        final int crtIdx = monitor.getId();
+        if( 0 > crtIdx || crtIdx >= crtProps.count ) {
+            throw new IndexOutOfBoundsException("monitor id "+crtIdx+" not withon [0.."+(crtProps.count-1)+"]");
+        }
+        final int[] fixedMonitorProps = crtProps.propsFixedArray[crtIdx];
+        int offset = MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT;
+        viewportPU.set(fixedMonitorProps[offset++], fixedMonitorProps[offset++], fixedMonitorProps[offset++], fixedMonitorProps[offset++]);
+        viewportWU.set(fixedMonitorProps[offset++], fixedMonitorProps[offset++], fixedMonitorProps[offset++], fixedMonitorProps[offset++]);
+        return true;
     }
 
     @Override
-    protected MonitorMode queryCurrentMonitorModeImpl(MonitorDevice monitor) {
+    protected MonitorMode queryCurrentMonitorModeImpl(final MonitorDevice monitor) {
         return getMonitorModeImpl(null, monitor.getId(), -1);
     }
 
     @Override
-    protected boolean setCurrentMonitorModeImpl(MonitorDevice monitor, MonitorMode mode)  {
+    protected boolean setCurrentMonitorModeImpl(final MonitorDevice monitor, final MonitorMode mode)  {
         return setMonitorMode0(monitor.getId(), mode.getId(), mode.getRotation());
     }
 
     @Override
-    protected int validateScreenIndex(int idx) {
+    protected int validateScreenIndex(final int idx) {
         return 0; // big-desktop w/ multiple monitor attached, only one screen available
     }
 
+    private native int getMonitorCount0();
     private native int[] getMonitorProps0(int crt_idx);
     private native int[] getMonitorMode0(int crt_index, int mode_idx);
     private native boolean setMonitorMode0(int crt_index, int nativeId, int rot);
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/macosx/WindowDriver.java
index eebf280de..540186f2e 100644
--- a/src/newt/classes/jogamp/newt/driver/macosx/WindowDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/macosx/WindowDriver.java
@@ -46,12 +46,15 @@ import javax.media.nativewindow.util.PointImmutable;
 
 import jogamp.nativewindow.macosx.OSXUtil;
 import jogamp.newt.PointerIconImpl;
+import jogamp.newt.ScreenImpl;
 import jogamp.newt.WindowImpl;
 import jogamp.newt.driver.DriverClearFocus;
 import jogamp.newt.driver.DriverUpdatePosition;
 
 import com.jogamp.newt.event.InputEvent;
 import com.jogamp.newt.event.KeyEvent;
+import com.jogamp.newt.event.MonitorEvent;
+import com.jogamp.opengl.math.FloatUtil;
 
 public class WindowDriver extends WindowImpl implements MutableSurface, DriverClearFocus, DriverUpdatePosition {
 
@@ -59,7 +62,81 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
         DisplayDriver.initSingleton();
     }
 
+    private int pixelScale;
+
     public WindowDriver() {
+        pixelScale = 1;
+    }
+
+    private boolean updatePixelScale(final boolean sendEvent, final boolean defer, final float newPixelScaleRaw) {
+        final int newPixelScaleSafe = FloatUtil.isZero(newPixelScaleRaw, FloatUtil.EPSILON) ? 1 : (int) newPixelScaleRaw;
+        final boolean changed = pixelScale != newPixelScaleSafe;
+        if( DEBUG_IMPLEMENTATION ) {
+            System.err.println("WindowDriver.updatePixelScale.X: "+pixelScale+" -> "+newPixelScaleSafe+" (raw "+newPixelScaleRaw+") - changed "+changed);
+        }
+        if( changed ) {
+            pixelScale = newPixelScaleSafe;
+            if( sendEvent ) {
+                super.sizeChanged(defer, getWindowWidth(), getWindowHeight(), true);
+            } else {
+                defineSize(getWindowWidth(), getWindowHeight());
+            }
+        }
+        return changed;
+    }
+
+    private boolean updatePixelScaleByScreenIdx(final boolean sendEvent) {
+        final float newPixelScaleRaw = (float) OSXUtil.GetPixelScale(getScreen().getIndex());
+        if( DEBUG_IMPLEMENTATION ) {
+            System.err.println("WindowDriver.updatePixelScale.1: "+pixelScale+" -> "+newPixelScaleRaw);
+        }
+        return updatePixelScale(sendEvent, true /* defer */, newPixelScaleRaw);
+    }
+
+    private boolean updatePixelScaleByWindowHandle(final boolean sendEvent) {
+        final long wh = getWindowHandle();
+        if( 0 != wh ) {
+            final float newPixelScaleRaw = (float)OSXUtil.GetPixelScale(wh);
+            if( DEBUG_IMPLEMENTATION ) {
+                System.err.println("WindowDriver.updatePixelScale.2: "+pixelScale+" -> "+newPixelScaleRaw);
+            }
+            return updatePixelScale(sendEvent, true /* defer */, newPixelScaleRaw);
+        } else {
+            return false;
+        }
+    }
+
+    /** Called from native code */
+    protected void updatePixelScale(final boolean defer, final float newPixelScaleRaw) {
+        final long handle = getWindowHandle();
+        if( 0 != handle ) {
+            if( DEBUG_IMPLEMENTATION ) {
+                System.err.println("WindowDriver.updatePixelScale.3: "+pixelScale+" -> "+newPixelScaleRaw);
+            }
+            updatePixelScale(true /* sendEvent*/, defer, newPixelScaleRaw);
+        }
+    }
+
+    @Override
+    protected final void instantiationFinished() {
+        updatePixelScaleByScreenIdx(false /* sendEvent*/);
+    }
+
+    @Override
+    protected void setScreen(ScreenImpl newScreen) { // never null !
+        super.setScreen(newScreen);
+        updatePixelScaleByScreenIdx(false /* sendEvent*/);  // caller (reparent, ..) will send reshape event
+    }
+
+
+    @Override
+    protected final int getPixelScaleX() {
+        return pixelScale;
+    }
+
+    @Override
+    protected final int getPixelScaleY() {
+        return pixelScale;
     }
 
     @Override
@@ -210,16 +287,6 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
     private boolean useParent(NativeWindow parent) { return null != parent && 0 != parent.getWindowHandle(); }
 
     @Override
-    protected final int getPixelScaleX() {
-        return 1; // FIXME HiDPI: Use pixelScale
-    }
-
-    @Override
-    protected final int getPixelScaleY() {
-        return 1; // FIXME HiDPI: Use pixelScale
-    }
-
-    @Override
     public void updatePosition(int x, int y) {
         final long handle = getWindowHandle();
         if( 0 != handle && !isOffscreenInstance ) {
@@ -263,11 +330,12 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
     }
 
     @Override
-    protected boolean reconfigureWindowImpl(final int x, final int y, final int width, final int height, int flags) {
+    protected boolean reconfigureWindowImpl(int x, int y, final int width, final int height, int flags) {
         final boolean _isOffscreenInstance = isOffscreenInstance(this, this.getParent());
         isOffscreenInstance = 0 != sscSurfaceHandle || _isOffscreenInstance;
         final PointImmutable pClientLevelOnSreen;
         if( isOffscreenInstance ) {
+            x = 0; y = 0;
             pClientLevelOnSreen = new Point(0, 0);
         } else  {
             final NativeWindow parent = getParent();
@@ -313,9 +381,9 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
             0 != ( FLAG_CHANGE_PARENTING & flags) ||
             0 != ( FLAG_CHANGE_FULLSCREEN & flags) ) {
             if(isOffscreenInstance) {
-                createWindow(true, 0 != getWindowHandle(), pClientLevelOnSreen, 64, 64, false, setVisible, false);
+                createWindow(true, 0 != getWindowHandle(), pClientLevelOnSreen, x, y, 64, 64, false, setVisible, false);
             } else {
-                createWindow(false, 0 != getWindowHandle(), pClientLevelOnSreen, width, height,
+                createWindow(false, 0 != getWindowHandle(), pClientLevelOnSreen, x, y, width, height,
                                     0 != ( FLAG_IS_FULLSCREEN & flags), setVisible, 0 != ( FLAG_IS_ALWAYSONTOP & flags));
             }
         } else {
@@ -329,7 +397,7 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
                 } // else offscreen size is realized via recreation
                 // no native event (fullscreen, some reparenting)
                 positionChanged(true,  x, y);
-                sizeChanged(true, width, height, false);
+                super.sizeChanged(true, width, height, false);
             }
             if( 0 != ( FLAG_CHANGE_VISIBILITY & flags) && setVisible ) {
                 if( !isOffscreenInstance ) {
@@ -439,11 +507,17 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
     @Override
     protected void warpPointerImpl(final int x, final int y) {
         if( !isOffscreenInstance ) {
-            warpPointer0(getWindowHandle(), x, y);
+            warpPointer0(getWindowHandle(), x / getPixelScaleX(), y / getPixelScaleY());
         } // else may need offscreen solution ? FIXME
     }
 
     @Override
+    protected final void doMouseEvent(final boolean enqueue, final boolean wait, final short eventType, final int modifiers,
+                                      final int x, final int y, final short button, final float[] rotationXYZ, final float rotationScale) {
+        super.doMouseEvent(enqueue, wait, eventType, modifiers, x * getPixelScaleX(), y * getPixelScaleY(), button, rotationXYZ, rotationScale);
+    }
+
+    @Override
     public final void sendKeyEvent(short eventType, int modifiers, short keyCode, short keySym, char keyChar) {
         throw new InternalError("XXX: Adapt Java Code to Native Code Changes");
     }
@@ -499,8 +573,8 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
     //
 
     private void createWindow(final boolean offscreenInstance, final boolean recreate,
-                              final PointImmutable pS, final int width, final int height,
-                              final boolean fullscreen, final boolean visible, final boolean alwaysOnTop) {
+                              final PointImmutable pS, final int x, final int y,
+                              final int width, final int height, final boolean fullscreen, final boolean visible, final boolean alwaysOnTop) {
 
         final long parentWinHandle = getParentWindowHandle();
         final long preWinHandle = getWindowHandle();
@@ -558,8 +632,12 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
                         setTitle0(newWin, getTitle());
                         setAlwaysOnTop0(getWindowHandle(), alwaysOnTop);
                     }
-                    visibleChanged(true, visible);
                 } } );
+            // no native event (fullscreen, some reparenting)
+            positionChanged(false,  x, y);
+            updatePixelScaleByWindowHandle(false /* sendEvent */);
+            super.sizeChanged(false, width, height, true);
+            visibleChanged(false, visible);
         } catch (Exception ie) {
             ie.printStackTrace();
         }
@@ -569,7 +647,8 @@ public class WindowDriver extends WindowImpl implements MutableSurface, DriverCl
     private native long createView0(int x, int y, int w, int h, boolean fullscreen);
     private native long createWindow0(int x, int y, int w, int h, boolean fullscreen, int windowStyle, int backingStoreType, long view);
     /** Must be called on Main-Thread */
-    private native void initWindow0(long parentWindow, long window, int x, int y, int w, int h, boolean opaque, boolean visible, long view);
+    private native void initWindow0(long parentWindow, long window, int x, int y, int w, int h,
+                                    boolean opaque, boolean visible, long view);
     private native boolean lockSurface0(long window, long view);
     private native boolean unlockSurface0(long window, long view);
     /** Must be called on Main-Thread */
diff --git a/src/newt/classes/jogamp/newt/driver/windows/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/windows/ScreenDriver.java
index e789b995f..af265cfd3 100644
--- a/src/newt/classes/jogamp/newt/driver/windows/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/windows/ScreenDriver.java
@@ -65,14 +65,14 @@ public class ScreenDriver extends ScreenImpl {
     protected void closeNativeImpl() {
     }
 
-    private final String getAdapterName(int crt_idx) {
+    private final String getAdapterName(final int crt_idx) {
         return getAdapterName0(crt_idx);
     }
-    private final String getActiveMonitorName(String adapterName, int monitor_idx) {
+    private final String getActiveMonitorName(final String adapterName, final int monitor_idx) {
         return getActiveMonitorName0(adapterName, monitor_idx);
     }
 
-    private final MonitorMode getMonitorModeImpl(MonitorModeProps.Cache cache, String adapterName, int crtModeIdx) {
+    private final MonitorMode getMonitorModeImpl(final MonitorModeProps.Cache cache, final String adapterName, final int crtModeIdx) {
         if( null == adapterName ) {
             return null;
         }
@@ -85,7 +85,7 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected void collectNativeMonitorModesAndDevicesImpl(MonitorModeProps.Cache cache) {
+    protected void collectNativeMonitorModesAndDevicesImpl(final MonitorModeProps.Cache cache) {
         int crtIdx = 0;
         ArrayHashSet<MonitorMode> supportedModes = new ArrayHashSet<MonitorMode>();
         String adapterName = getAdapterName(crtIdx);
@@ -118,26 +118,28 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected Rectangle getNativeMonitorDeviceViewportImpl(MonitorDevice monitor) {
+    protected boolean updateNativeMonitorDeviceViewportImpl(final MonitorDevice monitor, final Rectangle viewportPU, final Rectangle viewportWU) {
         final String adapterName = getAdapterName(monitor.getId());
         if( null != adapterName ) {
             final String activeMonitorName = getActiveMonitorName(adapterName, 0);
             if( null != activeMonitorName ) {
                 final int[] monitorProps = getMonitorDevice0(adapterName, monitor.getId());
                 int offset = MonitorModeProps.IDX_MONITOR_DEVICE_VIEWPORT;
-                return new Rectangle(monitorProps[offset++], monitorProps[offset++], monitorProps[offset++], monitorProps[offset++]);
+                viewportPU.set(monitorProps[offset++], monitorProps[offset++], monitorProps[offset++], monitorProps[offset++]);
+                viewportWU.set(monitorProps[offset++], monitorProps[offset++], monitorProps[offset++], monitorProps[offset++]);
+                return true;
             }
         }
-        return null;
+        return false;
     }
 
     @Override
-    protected MonitorMode queryCurrentMonitorModeImpl(MonitorDevice monitor) {
+    protected MonitorMode queryCurrentMonitorModeImpl(final MonitorDevice monitor) {
         return getMonitorModeImpl(null, getAdapterName(monitor.getId()), -1);
     }
 
     @Override
-    protected boolean setCurrentMonitorModeImpl(MonitorDevice monitor, MonitorMode mode)  {
+    protected boolean setCurrentMonitorModeImpl(final MonitorDevice monitor, final MonitorMode mode)  {
         return setMonitorMode0(monitor.getId(),
                                -1, -1, // no fixed position!
                                mode.getSurfaceSize().getResolution().getWidth(),
@@ -149,13 +151,13 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected int validateScreenIndex(int idx) {
+    protected int validateScreenIndex(final int idx) {
         return 0; // big-desktop w/ multiple monitor attached, only one screen available
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(Rectangle vOriginSize) {
-        vOriginSize.set(getVirtualOriginX0(), getVirtualOriginY0(), getVirtualWidthImpl0(), getVirtualHeightImpl0());
+    protected void calcVirtualScreenOriginAndSize(final Rectangle viewport, Rectangle viewportInWindowUnits) {
+        viewport.set(getVirtualOriginX0(), getVirtualOriginY0(), getVirtualWidthImpl0(), getVirtualHeightImpl0());
     }
 
     // Native calls
diff --git a/src/newt/classes/jogamp/newt/driver/x11/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/x11/ScreenDriver.java
index bef7f60ec..2d7c6509d 100644
--- a/src/newt/classes/jogamp/newt/driver/x11/ScreenDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/x11/ScreenDriver.java
@@ -111,7 +111,7 @@ public class ScreenDriver extends ScreenImpl {
     private RandR rAndR;
 
     @Override
-    protected final void collectNativeMonitorModesAndDevicesImpl(MonitorModeProps.Cache cache) {
+    protected final void collectNativeMonitorModesAndDevicesImpl(final MonitorModeProps.Cache cache) {
         if( null == rAndR ) { return; }
         final AbstractGraphicsDevice device = getDisplay().getGraphicsDevice();
         device.lock();
@@ -165,12 +165,14 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected Rectangle getNativeMonitorDeviceViewportImpl(MonitorDevice monitor) {
+    protected boolean updateNativeMonitorDeviceViewportImpl(final MonitorDevice monitor, final Rectangle viewportPU, final Rectangle viewportWU) {
         final AbstractGraphicsDevice device = getDisplay().getGraphicsDevice();
         device.lock();
         try {
             int[] viewportProps = rAndR.getMonitorDeviceViewport(device.getHandle(), this, monitor.getId());
-            return new Rectangle(viewportProps[0], viewportProps[1], viewportProps[2], viewportProps[3]);
+            viewportPU.set(viewportProps[0], viewportProps[1], viewportProps[2], viewportProps[3]);
+            viewportWU.set(viewportProps[0], viewportProps[1], viewportProps[2], viewportProps[3]); // equal window-units and pixel-units
+            return true;
         } finally {
             device.unlock();
         }
@@ -207,7 +209,7 @@ public class ScreenDriver extends ScreenImpl {
         return done;
     }
 
-    private DisplayImpl.DisplayRunnable<Boolean> xineramaEnabledQueryWithTemp = new DisplayImpl.DisplayRunnable<Boolean>() {
+    private final DisplayImpl.DisplayRunnable<Boolean> xineramaEnabledQueryWithTemp = new DisplayImpl.DisplayRunnable<Boolean>() {
         @Override
         public Boolean run(long dpy) {
             return new Boolean(X11Util.XineramaIsEnabled(dpy));
@@ -225,8 +227,8 @@ public class ScreenDriver extends ScreenImpl {
     }
 
     @Override
-    protected void calcVirtualScreenOriginAndSize(final Rectangle vOriginSize) {
-        final RectangleImmutable ov = (RectangleImmutable) getViewport().cloneMutable();
+    protected void calcVirtualScreenOriginAndSize(final Rectangle viewport, Rectangle viewportInWindowUnits) {
+        final RectangleImmutable ov = DEBUG ? (RectangleImmutable) getViewport().cloneMutable() : null;
         /**
         if( null != rAndR && rAndR.getVersion().compareTo(RandR.version130) >= 0 && getMonitorDevices().size()>0 ) {
             super.calcVirtualScreenOriginAndSize(vOriginSize);
@@ -242,11 +244,11 @@ public class ScreenDriver extends ScreenImpl {
             runWithLockedDisplayDevice( new DisplayImpl.DisplayRunnable<Object>() {
                 @Override
                 public Object run(long dpy) {
-                    vOriginSize.set(0, 0, getWidth0(dpy, screen_idx), getHeight0(dpy, screen_idx));
+                    viewport.set(0, 0, getWidth0(dpy, screen_idx), getHeight0(dpy, screen_idx));
                     return null;
                 } } );
             if( DEBUG ) {
-                System.err.println("X11Screen.calcVirtualScreenOriginAndSize: Querying X11: "+ov+" -> "+vOriginSize);
+                System.err.println("X11Screen.calcVirtualScreenOriginAndSize: Querying X11: "+ov+" -> "+viewport);
             }
         }
     }
@@ -254,11 +256,11 @@ public class ScreenDriver extends ScreenImpl {
     //----------------------------------------------------------------------
     // Internals only
     //
-    private final <T> T runWithLockedDisplayDevice(DisplayRunnable<T> action) {
+    private final <T> T runWithLockedDisplayDevice(final DisplayRunnable<T> action) {
         return display.runWithLockedDisplayDevice(action);
     }
 
-    private final <T> T runWithTempDisplayHandle(DisplayRunnable<T> action) {
+    private final <T> T runWithTempDisplayHandle(final DisplayRunnable<T> action) {
         final long displayHandle = X11Util.openDisplay(display.getName());
         if(0 == displayHandle) {
             throw new RuntimeException("null device");
@@ -272,7 +274,7 @@ public class ScreenDriver extends ScreenImpl {
         return res;
     }
 
-    private final <T> T runWithOptTempDisplayHandle(DisplayRunnable<T> action) {
+    private final <T> T runWithOptTempDisplayHandle(final DisplayRunnable<T> action) {
         if( null != rAndR && rAndR.getVersion().compareTo(RandR.version130) >= 0 ) {
             return display.runWithLockedDisplayDevice(action);
         } else {