Add Qt auto-rotation for landscape pages and bump to v0.9.4

Extract landscape detection into shared orientation module used by both
PDF and Qt devices.  Qt window now auto-rotates landscape content rendered
on portrait pages (DSC first, CTM heuristic fallback).  DPI auto-calculation
accounts for post-rotation display height via DSC orientation hint.  Window
sizing uses wider caps (85%) for landscape pages.

Author: AndyCappDev

postforge/cli_runner.py

@@ -48,7 +48,6 @@ def _auto_set_qt_resolution(ctxt: ps.Context) -> None:
     except Exception:
         return  # Can't determine screen size, keep default
 
-    max_w = int(screen_w * 0.60)
     max_h = int(screen_h * 0.85)
 
     pd = ctxt.gstate.page_device
@@ -58,10 +57,17 @@ def _auto_set_qt_resolution(ctxt: ps.Context) -> None:
     if page_w <= 0 or page_h <= 0:
         return
 
-    # DPI that would make the page fit exactly in the max window
-    dpi_for_width = max_w * 72.0 / page_w
-    dpi_for_height = max_h * 72.0 / page_h
-    dpi = int(min(dpi_for_width, dpi_for_height))
+    # Determine the post-rotation display height in points.  DSC orientation
+    # tells us before execution whether the page will be auto-rotated —
+    # same principle as pre-setting PageSize from EPS BoundingBox.
+    dsc_orient = pd.get(b'DSCOrientation')
+    if dsc_orient is not None and dsc_orient.val == b'Landscape' and page_w < page_h:
+        # After 90° rotation the shorter dimension becomes the display height
+        display_height_pts = min(page_w, page_h)
+    else:
+        display_height_pts = page_h
+
+    dpi = int(max_h * 72.0 / display_height_pts)
 
     # Clamp to reasonable range
     dpi = max(36, min(dpi, 9600))
@@ -273,6 +279,15 @@ def _conditional_paint(ctxt, elem):
                     page_size.setval([ps.Real(eps_w), ps.Real(eps_h)])
                     ctxt.gstate.page_device[b"PageSize"] = page_size
 
+        # Parse DSC orientation hint for DPI auto-calculation.  Landscape
+        # pages need a higher DPI because the shorter page dimension becomes
+        # the display height after auto-rotation.
+        if inputfiles and device == "qt":
+            dsc = parse_dsc_header(inputfiles[0])
+            if dsc.orientation:
+                ctxt.gstate.page_device[b'DSCOrientation'] = \
+                    ps.Name(dsc.orientation.encode('ascii'))
+
         # Override HWResolution if --resolution flag was provided
         if args.resolution:
             hw_res = ps.Array(ctxt.id)

postforge/core/display_list_builder.py

@@ -63,6 +63,18 @@ def add_graphics_operation(self, ctxt: Any, graphics_element: Any) -> None:
         # so we don't need to create them here
         ctxt.display_list.append(graphics_element)
 
+        # Tally CTM x-axis direction for orientation detection.
+        # Classifies each paint op's CTM to the nearest 90° and increments
+        # the corresponding counter — fixed 4-int overhead per page.
+        ctm_arr = ctxt.gstate.CTM.val
+        a, b = ctm_arr[0].val, ctm_arr[1].val
+        if a * a + b * b >= 1e-10:
+            votes = ctxt.display_list.rotation_votes
+            if abs(a) >= abs(b):
+                votes[0 if a >= 0 else 2] += 1   # 0° or 180°
+            else:
+                votes[3 if b >= 0 else 1] += 1   # 270° or 90°
+
         # Notify Qt device (or other interactive device) to refresh if callback registered
         # This enables live rendering in interactive mode
         if hasattr(ctxt, 'on_paint_callback') and ctxt.on_paint_callback:

postforge/core/types/graphics.py

@@ -135,6 +135,11 @@ def __init__(self, width: int = 0, height: int = 0) -> None:
 
         self.width = width
         self.height = height
+        # CTM rotation vote counters collected during painting ops.
+        # Each paint operation's CTM x-axis is classified to the nearest
+        # 90° and tallied here.  Used by orientation detection to determine
+        # content rotation — fixed 4-int cost regardless of document size.
+        self.rotation_votes: list[int] = [0, 0, 0, 0]  # [0°, 90°, 180°, 270°]
 
     """
     This is a list of elements like Paths, Fills, Strokes, etc...

postforge/devices/common/orientation.py

@@ -0,0 +1,53 @@
+# PostForge - A PostScript Interpreter
+# Copyright (c) 2025-2026 Scott Bowman
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+from __future__ import annotations
+
+"""
+Orientation detection for PostScript pages.
+
+Provides a device-agnostic heuristic to detect landscape content rendered
+onto portrait pages (e.g., PostScript files that use ``90 rotate``).
+"""
+
+
+def detect_landscape(display_list: list, width_pts: float,
+                     height_pts: float) -> int:
+    """Heuristic fallback for landscape detection when DSC is absent.
+
+    Reads pre-tallied CTM rotation votes from the display list to determine
+    the dominant content rotation.  Each painting operation's CTM x-axis
+    direction was classified to the nearest 90° during display list
+    construction.  If the vast majority agree on a non-zero rotation, that
+    value is returned as the page rotation angle.
+
+    Args:
+        display_list: Display list from the context (with ``rotation_votes``).
+        width_pts: Page width in points.
+        height_pts: Page height in points.
+
+    Returns:
+        Rotation angle (0, 90, or 270).
+    """
+    # Only consider portrait pages
+    if width_pts >= height_pts:
+        return 0
+
+    votes = getattr(display_list, 'rotation_votes', None)
+    if not votes:
+        return 0
+
+    # votes layout: [0°, 90°, 180°, 270°]
+    total = sum(votes)
+    if total < 5:
+        return 0
+
+    angle_map = {0: 0, 1: 90, 2: 180, 3: 270}
+    best_idx = max(range(4), key=lambda i: votes[i])
+    best_angle = angle_map[best_idx]
+
+    # Only apply rotation for landscape orientations (90/270)
+    if best_angle in (90, 270) and votes[best_idx] > total * 0.8:
+        return best_angle
+    return 0

postforge/devices/pdf/pdf.py

@@ -18,6 +18,7 @@
 import os
 
 from ...core import types as ps
+from ..common.orientation import detect_landscape
 from .font_tracker import FontTracker
 from .font_embedder import FontEmbedder
 from .cff_font_embedder import CFFEmbedder
@@ -179,7 +180,7 @@ def showpage(ctxt: ps.Context, pd: dict) -> None:
         if dsc_orient is not None and dsc_orient.val == b'Landscape':
             page_rotate = 90
         else:
-            page_rotate = _detect_landscape(
+            page_rotate = detect_landscape(
                 ctxt.display_list, width_pts, height_pts)
 
     # Store page data
@@ -250,54 +251,3 @@ def _is_type42_font(font_dict: ps.Dict) -> bool:
     return font_type is not None and font_type.val == 42
 
 
-def _detect_landscape(display_list: list, width_pts: float,
-                       height_pts: float) -> int:
-    """Heuristic fallback for landscape detection when DSC is absent.
-
-    Examines CTMs of display list elements to determine the dominant content
-    rotation.  Each element's x-axis direction ``(a, b)`` is classified to
-    the nearest 90-degree multiple.  If the vast majority agree on a non-zero
-    rotation, that value is returned as the page ``/Rotate``.
-
-    Args:
-        display_list: Display list elements from the context.
-        width_pts: Page width in PDF points.
-        height_pts: Page height in PDF points.
-
-    Returns:
-        Rotation angle (0, 90, or 270).
-    """
-    # Only consider portrait pages
-    if width_pts >= height_pts:
-        return 0
-
-    votes: dict[int, int] = {0: 0, 90: 0, 180: 0, 270: 0}
-    for item in display_list:
-        ctm = getattr(item, 'ctm', None)
-        if ctm is None or len(ctm) < 4:
-            continue
-        a, b = ctm[0], ctm[1]
-        if a * a + b * b < 1e-10:
-            continue
-        # Classify x-axis direction to nearest 90°.
-        # The content stream's initial cm has a negative y-scale (y-flip)
-        # which mirrors the rotation direction: a PS +90° CCW rotation
-        # appears as -90° in the rendered PDF.  Swap 90↔270 to produce
-        # the correct /Rotate value that compensates.
-        if abs(a) >= abs(b):
-            nearest = 0 if a >= 0 else 180
-        else:
-            nearest = 270 if b >= 0 else 90
-        votes[nearest] += 1
-
-    total = sum(votes.values())
-    if total < 5:
-        return 0
-
-    best = max(votes, key=votes.get)
-    # Only apply rotation for landscape orientations (90/270)
-    if best in (90, 270) and votes[best] > total * 0.8:
-        return best
-    return 0
-
-

postforge/devices/qt/qt.py

@@ -47,12 +47,13 @@ def _get_antialias_mode(pd: dict) -> int:
 
 from ...core import types as ps
 from ..common.cairo_renderer import render_display_list
+from ..common.orientation import detect_landscape
 
 # Check for PySide6 availability
 try:
     from PySide6.QtWidgets import QApplication, QMainWindow, QWidget
     from PySide6.QtCore import Qt
-    from PySide6.QtGui import QImage, QPainter, QKeyEvent, QWheelEvent, QMouseEvent, QCursor
+    from PySide6.QtGui import QImage, QPainter, QKeyEvent, QWheelEvent, QMouseEvent, QCursor, QTransform
     PYSIDE6_AVAILABLE = True
 except ImportError:
     PYSIDE6_AVAILABLE = False
@@ -302,9 +303,9 @@ def _ensure_window(page_width: float | None = None, page_height: float | None =
     If the rendered image is smaller than what would fill the default window,
     the window shrinks to fit the image at 1:1 pixel size instead of enlarging it.
 
-    Width is capped at 60% of screen width and height at 85% of screen height,
-    so landscape content doesn't produce overly wide windows while portrait
-    content still uses most of the vertical space.
+    Portrait pages use 60% width / 85% height caps so windows stay narrow.
+    Landscape pages (after auto-rotation) use 85% width / 85% height so the
+    wider content gets adequate horizontal space.
 
     Args:
         page_width: Page width (any units, used for aspect ratio)
@@ -327,12 +328,15 @@ def _ensure_window(page_width: float | None = None, page_height: float | None =
         screen_width = available.width()
         screen_height = available.height()
 
-        # Calculate maximum window size — 60% width, 85% height
-        max_width = int(screen_width * 0.60)
+        # Landscape pages get more horizontal space; portrait pages stay narrow
+        if page_width > page_height:
+            max_width = int(screen_width * 0.85)
+        else:
+            max_width = int(screen_width * 0.60)
         max_height = int(screen_height * 0.85)
 
         if image_width and image_height:
-            # Use exact image pixel dimensions, capped at max screen size
+            # Use image pixel dimensions, capped at max screen size
             win_width = image_width
             win_height = image_height
 
@@ -428,6 +432,31 @@ def _wait_for_keypress(ctxt: ps.Context) -> None:
         _app.processEvents()
 
 
+def _detect_page_rotation(pd: dict, display_list: list,
+                          width_pts: float, height_pts: float) -> int:
+    """Detect page rotation for landscape content on portrait pages.
+
+    Uses DSC ``%%Orientation`` when available (set by cli_runner from DSC
+    parsing), otherwise falls back to CTM heuristic analysis.  Only applies
+    to portrait pages — landscape MediaBox pages need no rotation.
+
+    Args:
+        pd: Page device dictionary.
+        display_list: Display list elements from the context.
+        width_pts: Page width in points.
+        height_pts: Page height in points.
+
+    Returns:
+        Rotation angle (0, 90, or 270).
+    """
+    if width_pts >= height_pts:
+        return 0
+    dsc_orient = pd.get(b'DSCOrientation')
+    if dsc_orient is not None and dsc_orient.val == b'Landscape':
+        return 90
+    return detect_landscape(display_list, width_pts, height_pts)
+
+
 def _render_to_window(ctxt: ps.Context, pd: dict) -> None:
     """Render the current display list to the Qt window.
 
@@ -457,43 +486,31 @@ def _render_to_window(ctxt: ps.Context, pd: dict) -> None:
     device_w = pd[b"MediaSize"].get(ps.Int(0))[1].val
     device_h = pd[b"MediaSize"].get(ps.Int(1))[1].val
 
-    # Cap render dimensions to avoid Cairo surface allocation failures
-    # on screen display. When the device resolution produces surfaces
-    # larger than this limit, render to a smaller surface and scale the
-    # Cairo context so the display list (in device coords) fits.
-    MAX_SURFACE_PIXELS = 16384
-    downscale = 1.0
-    render_w = device_w
-    render_h = device_h
-    if device_w > MAX_SURFACE_PIXELS or device_h > MAX_SURFACE_PIXELS:
-        downscale = MAX_SURFACE_PIXELS / max(device_w, device_h)
-        render_w = int(device_w * downscale)
-        render_h = int(device_h * downscale)
-
-    # Calculate page dimensions in points for window sizing (from actual HWResolution)
+    # Calculate page dimensions in points (from actual HWResolution)
     hw_dpi = pd[b"HWResolution"].get(ps.Int(0))[1].val
-    scale = hw_dpi / 72.0
-    _page_width = device_w / scale
-    _page_height = device_h / scale
-
-    # Create Cairo surface at (possibly capped) render resolution
+    dpi_scale = hw_dpi / 72.0
+    _page_width = device_w / dpi_scale
+    _page_height = device_h / dpi_scale
+
+    # Detect rotation for landscape content on portrait pages
+    page_rotate = _detect_page_rotation(
+        pd, ctxt.display_list, _page_width, _page_height)
+
+    # Create Cairo surface at device resolution (DPI was pre-computed by
+    # _auto_set_qt_resolution to fill ~85% of screen height)
+    render_w = int(device_w)
+    render_h = int(device_h)
     _surface = cairo.ImageSurface(cairo.FORMAT_RGB24, render_w, render_h)
     cc = cairo.Context(_surface)
 
     cc.identity_matrix()
-    # Scale Cairo context to map device coordinates into the capped surface
-    if downscale != 1.0:
-        cc.scale(downscale, downscale)
     # Convert PostScript flatness to Cairo tolerance (PS default 1.0 → Cairo default 0.1)
     cc.set_tolerance(ctxt.gstate.flatness / 10.0)
 
-    # Fill white background (in surface coordinates)
-    cc.save()
-    cc.identity_matrix()
+    # Fill white background
     cc.set_source_rgb(1.0, 1.0, 1.0)
     cc.rectangle(0, 0, render_w, render_h)
     cc.fill()
-    cc.restore()
 
     cc.set_antialias(_get_antialias_mode(pd))
 
@@ -503,12 +520,17 @@ def _render_to_window(ctxt: ps.Context, pd: dict) -> None:
     # Convert Cairo surface to QImage
     _qimage = _cairo_surface_to_qimage(_surface)
 
+    # Auto-rotate landscape content rendered on portrait pages
+    if page_rotate in (90, 270):
+        _qimage = _qimage.transformed(QTransform().rotate(page_rotate))
+        _page_width, _page_height = _page_height, _page_width
+
     # Reset view state for new page
     _zoom_level = 1.0
     _pan_x = 0
     _pan_y = 0
 
-    # Ensure window exists and update (use page dimensions in points for aspect ratio)
+    # Ensure window exists and update
     _ensure_window(_page_width, _page_height, _qimage.width(), _qimage.height())
 
     _canvas.update()

postforge/resources/Init/sysdict.ps

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "postforge"
-version = "0.9.3"
+version = "0.9.4"
 description = "A PostScript interpreter written in Python"
 authors = [{name = "Scott Bowman", email = "scott@bowmans.org"}]
 readme = "README.md"