feat: implement RenderHandler.GetScreenInfo with HiDPI support

Wires the previously-stubbed RenderHandler_GetScreenInfo through to a
Python callback that fills a screen_info_out dict (device_scale_factor,
depth, depth_per_component, is_monochrome, rect, available_rect).
Asserts device_scale_factor > 0 to prevent compositor divide-by-zero,
mirrors rect into available_rect when only one is supplied, and
documents the OnPaint buffer-scaling implications for HiDPI displays.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: linesight

api/API-index.md

@@ -349,6 +349,7 @@
   * [GetViewRect](RenderHandler.md#getviewrect)
   * [GetScreenRect](RenderHandler.md#getscreenrect)
   * [GetScreenPoint](RenderHandler.md#getscreenpoint)
+  * [GetScreenInfo](RenderHandler.md#getscreeninfo)
   * [OnPopupShow](RenderHandler.md#onpopupshow)
   * [OnPopupSize](RenderHandler.md#onpopupsize)
   * [OnPaint](RenderHandler.md#onpaint)

api/RenderHandler.md

@@ -17,6 +17,7 @@ Table of contents:
   * [GetViewRect](#getviewrect)
   * [GetScreenRect](#getscreenrect)
   * [GetScreenPoint](#getscreenpoint)
+  * [GetScreenInfo](#getscreeninfo)
   * [OnPopupShow](#onpopupshow)
   * [OnPopupSize](#onpopupsize)
   * [OnPaint](#onpaint)
@@ -43,7 +44,6 @@ Off-screen rendering examples:
 
 Callbacks available in upstream CEF, but not yet exposed in CEF Python
 (see src/include/cef_render_handler.h):
-* GetScreenInfo
 * OnImeCompositionRangeChanged
 
 
@@ -100,6 +100,46 @@ Called to retrieve the translation from view coordinates to actual
 screen coordinates. Return true if the screen coordinates were provided.
 
 
+### GetScreenInfo
+
+| Parameter | Type |
+| --- | --- |
+| browser | [Browser](Browser.md) |
+| screen_info_out | dict |
+| __Return__ | bool |
+
+Called to allow the client to fill in the screen info with appropriate
+values. Return true if `screen_info_out` was modified, false to let CEF
+use defaults.
+
+Fill `screen_info_out` with any of the following keys (all optional):
+
+| Key | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `device_scale_factor` | float | `1.0` | Ratio between physical and logical pixels. **Must be > 0.** |
+| `depth` | int | `24` | Screen depth in bits per pixel. |
+| `depth_per_component` | int | `8` | Bits per color component. |
+| `is_monochrome` | bool | `False` | True for black-and-white printers. |
+| `rect` | list[x,y,width,height] | unset | Display monitor rectangle in DIP. |
+| `available_rect` | list[x,y,width,height] | unset | Work-area rectangle in DIP (excludes taskbars). If only `rect` is supplied it is mirrored into `available_rect`. |
+
+If neither `rect` nor `available_rect` is supplied, CEF falls back to
+the rectangle returned by `GetViewRect` (popups may be misplaced if
+the rectangle ends up empty).
+
+**HiDPI handling:** set `device_scale_factor` to match the host
+display (e.g. `2.0` on a Retina/4K screen, `1.5` for 150% fractional
+scaling). The factor is applied to the OnPaint buffer: with a view
+rect of 800x600 and `device_scale_factor=2.0`, OnPaint receives a
+1600x1200 BGRA buffer while `width`/`height` arguments equal the
+buffer's pixel dimensions. Always upload the buffer at its actual
+pixel size and lay it out at the view's logical size to avoid
+blurry output. Call
+[Browser.NotifyScreenInfoChanged](Browser.md#notifyscreeninfochanged)
+when the device scale factor or display geometry changes (e.g. the
+window moved to a different monitor) so CEF re-queries this callback.
+
+
 ### OnPopupShow
 
 | Parameter | Type |

src/handlers/render_handler.pyx

@@ -147,8 +147,66 @@ cdef public cpp_bool RenderHandler_GetScreenInfo(
         CefRefPtr[CefBrowser] cefBrowser,
         CefScreenInfo& cefScreenInfo
         ) except * with gil:
-    # Not yet implemented.
-    return False
+    cdef PyBrowser pyBrowser
+    cdef dict pyScreenInfo = {}
+    cdef py_bool ret
+    cdef list pyRect
+    cdef double deviceScaleFactor
+    try:
+        pyBrowser = GetPyBrowser(cefBrowser, "GetScreenInfo")
+        callback = pyBrowser.GetClientCallback("GetScreenInfo")
+        if not callback:
+            return False
+        ret = callback(browser=pyBrowser, screen_info_out=pyScreenInfo)
+        if not ret:
+            return False
+        # device_scale_factor is the ratio between physical and logical
+        # pixels. On HiDPI displays this is typically 2.0 (1.25/1.5/1.75
+        # for fractional scaling). It MUST be > 0 -- a value of 0 will
+        # divide-by-zero inside Chromium's compositor. Setting this also
+        # scales the OnPaint buffer: a 800x600 view rect with
+        # device_scale_factor=2.0 yields a 1600x1200 BGRA buffer.
+        if "device_scale_factor" in pyScreenInfo:
+            deviceScaleFactor = float(pyScreenInfo["device_scale_factor"])
+            assert deviceScaleFactor > 0.0, (
+                    "device_scale_factor must be > 0")
+            cefScreenInfo.device_scale_factor = <float>deviceScaleFactor
+        else:
+            cefScreenInfo.device_scale_factor = 1.0
+        cefScreenInfo.depth = int(pyScreenInfo.get("depth", 24))
+        cefScreenInfo.depth_per_component = int(
+                pyScreenInfo.get("depth_per_component", 8))
+        cefScreenInfo.is_monochrome = <cpp_bool>bool(
+                pyScreenInfo.get("is_monochrome", False))
+        # rect/available_rect are in DIP (logical pixels). Leaving them
+        # zero-initialized tells CEF to fall back to GetViewRect (see
+        # cef_render_handler.h:107).
+        if "rect" in pyScreenInfo:
+            pyRect = list(pyScreenInfo["rect"])
+            assert len(pyRect) == 4, "rect must be [x, y, width, height]"
+            cefScreenInfo.rect.x = int(pyRect[0])
+            cefScreenInfo.rect.y = int(pyRect[1])
+            cefScreenInfo.rect.width = int(pyRect[2])
+            cefScreenInfo.rect.height = int(pyRect[3])
+        if "available_rect" in pyScreenInfo:
+            pyRect = list(pyScreenInfo["available_rect"])
+            assert len(pyRect) == 4, (
+                    "available_rect must be [x, y, width, height]")
+            cefScreenInfo.available_rect.x = int(pyRect[0])
+            cefScreenInfo.available_rect.y = int(pyRect[1])
+            cefScreenInfo.available_rect.width = int(pyRect[2])
+            cefScreenInfo.available_rect.height = int(pyRect[3])
+        elif "rect" in pyScreenInfo:
+            # Mirror rect into available_rect so popups place correctly
+            # when the caller only supplied one.
+            cefScreenInfo.available_rect.x = cefScreenInfo.rect.x
+            cefScreenInfo.available_rect.y = cefScreenInfo.rect.y
+            cefScreenInfo.available_rect.width = cefScreenInfo.rect.width
+            cefScreenInfo.available_rect.height = cefScreenInfo.rect.height
+        return True
+    except:
+        (exc_type, exc_value, exc_trace) = sys.exc_info()
+        sys.excepthook(exc_type, exc_value, exc_trace)
 
 cdef public void RenderHandler_OnPopupShow(
         CefRefPtr[CefBrowser] cefBrowser,