Output Management

def get_outputs(self) -> List[OutputReply]:
    """
    Get information about all outputs/monitors.
    
    Returns:
    List[OutputReply]: comprehensive output details for all connected displays
    """

class OutputReply:
    """Complete output information from GET_OUTPUTS response."""
    
    # Basic identification
    name: str  # Output name (e.g., "HDMI-A-1", "eDP-1")
    active: bool  # Whether output is currently active and usable
    primary: bool  # Whether output is designated as primary display
    
    # Workspace assignment
    current_workspace: str  # Name of workspace currently displayed on this output
    
    # Geometry and positioning
    rect: Rect  # Output rectangle (position and dimensions)
    
    # Sway-specific properties (None in i3)
    make: str  # Monitor manufacturer
    model: str  # Monitor model name
    serial: str  # Monitor serial number
    scale: float  # Display scaling factor
    transform: str  # Display transformation (normal, 90, 180, 270, flipped-90, etc.)
    max_render_time: int  # Maximum render time in milliseconds
    focused: bool  # Whether output currently has focus
    dpms: bool  # DPMS (power management) state
    subpixel_hinting: str  # Subpixel rendering mode
    modes: List[OutputMode]  # Available display modes
    current_mode: OutputMode  # Currently active display mode
    
    # Raw data access
    ipc_data: dict  # Complete raw IPC response data

class OutputMode:
    """Display mode specification for sway outputs."""
    width: int  # Mode width in pixels
    height: int  # Mode height in pixels
    refresh: int  # Refresh rate in mHz (millihertz)
    
    def __getitem__(self, item):
        """Dictionary-style access for backwards compatibility."""
    
    @classmethod
    def _parse_list(cls, data) -> List[OutputMode]:
        """Parse list of mode data into OutputMode objects."""

class Rect:
    """Rectangle dimensions and positioning for outputs."""
    x: int  # X coordinate of output in global coordinate system
    y: int  # Y coordinate of output in global coordinate system
    width: int  # Output width in pixels
    height: int  # Output height in pixels

# Get all outputs and display their information
outputs = i3.get_outputs()
for output in outputs:
    print(f"Output: {output.name}")
    print(f"  Active: {output.active}")
    if output.active:
        print(f"  Primary: {output.primary}")
        print(f"  Current workspace: {output.current_workspace}")
        print(f"  Dimensions: {output.rect.width}x{output.rect.height}")
        print(f"  Position: ({output.rect.x}, {output.rect.y})")
        
        # Sway-specific information
        if hasattr(output, 'make') and output.make:
            print(f"  Monitor: {output.make} {output.model}")
            print(f"  Scale: {output.scale}x")
            print(f"  Transform: {output.transform}")
            print(f"  Focused: {output.focused}")
            
            if output.current_mode:
                mode = output.current_mode
                refresh_hz = mode.refresh / 1000  # Convert mHz to Hz
                print(f"  Current mode: {mode.width}x{mode.height}@{refresh_hz}Hz")
            
            print(f"  Available modes: {len(output.modes)}")
            for mode in output.modes[:3]:  # Show first 3 modes
                refresh_hz = mode.refresh / 1000
                print(f"    {mode.width}x{mode.height}@{refresh_hz}Hz")

# Find active outputs
active_outputs = [output for output in outputs if output.active]
print(f"Active outputs: {len(active_outputs)}")

# Find primary output
primary_output = next((output for output in outputs if output.primary), None)
if primary_output:
    print(f"Primary output: {primary_output.name}")

# Map workspaces to outputs
workspace_to_output = {}
for output in active_outputs:
    if output.current_workspace:
        workspace_to_output[output.current_workspace] = output.name

print("Workspace -> Output mapping:")
for workspace, output_name in workspace_to_output.items():
    print(f"  {workspace} -> {output_name}")