�
�h� � �� � d Z ddlZddlZddlZddlZddlmZmZmZm Z ddl
m Z ddl Z
ddlmZ ddlZddlmZmZmZ ej* e� Zdefd�Z G d � d
� Z G d � d � Z G d
� d� Z dee fd�Z y)z�
Screenshot capture functionality for Linux systems and Windows (via WSL2).
Uses pyscreenshot for cross-platform screenshot capability.
� N)�List�Dict�Optional�Tuple)�Path)�Image)�
get_config�get_output_directory�generate_page_filename�returnc �t � t j j d� rFt dd� 5 } | j � j � }d|v sd|v r
ddd� y ddd� t
j � dk( ryy# 1 sw Y �"xY w# t $ r"}t j d |� �� Y d}~yd}~ww xY w)
z�
Detect the current runtime environment.
Returns:
'wsl' if running in WSL (can access Windows)
'linux' if running in native Linux
'windows' if running in native Windows
z
/proc/version�r� microsoft�wslN�Windows�windows�linuxz Could not detect environment: ) �os�path�exists�open�read�lower�platform�system� Exception�logger�warning)�f� version_info�es �+/home/luispoveda93/auto-snap-mcp/capture.py�detect_environmentr# s� � ��
�7�7�>�>�/� *��o�s�+�
!�q� �v�v�x�~�~� /� � �,�.�%�<�2G� �
!�
!�2G�
!� �?�?� � � )� � �
!�
!�� � ����7��s�;�<����s4 �+B �(B �B � B � B �B � B7�B2�2B7c � � e Zd ZdZd� Zdefd�Zdeee e f fd�Z
dde de e de fd �Z d
e de fd �Z
dde e de fd �Zdee ef fd
�Zde de fd�Zde de defd�Z dde dede e de dedee f d�Zde defd�Zde dedefd�Zy) �WindowsWindowManagerzIHandles Windows application enumeration and screenshot capture from WSL2.c �. � | j � | _ y �N)�_check_powershell�powershell_available��selfs r" �__init__z WindowsWindowManager.__init__4 s � �$(�$:�$:�$<��!� r c �` � t j d� t j g d�dddd�� }t j d� y# t j $ r t j d� Y yt j t f$ r"}t j d |� �� Y d
}~yd
}~ww xY w) z+Check if PowerShell is available from WSL2.z#Checking PowerShell availability...)�powershell.exe�-CommandzWrite-Host "test"T�
��capture_output�text�check�timeoutzPowerShell is availablez+PowerShell check timed out after 10 secondsFz$PowerShell not available from WSL2: N)r �info�
subprocess�run�TimeoutExpired�error�CalledProcessError�FileNotFoundError)r+ �resultr! s r" r( z&WindowsWindowManager._check_powershell7 s� � � � �K�K�=� >� �^�^�C� #���� �F�
�K�K�1� 2����(�(� � �L�L�F� G���-�-�/@�A� � �L�L�?��s�C� D��� �s �AA � (B-�3B-� B(�(B-c � � | j st j d� g S d}t j dd|gdddddd� � }d
d l}|j j � �r� |j |j j � � }t |t � r|g}g }|D ]� }t |j d d
� � }|d
k( r�$|j t |j dd� � |j dd� |j dd� t |j dd� � ||j dd� |j dd� |j dd� |j dd� dd�
� �� t j dt |� � d �� |rUt! d � |D � � }t! d � |D � � } t! d � |D � � }
t j d |� d!| � d"|
� d#�� |S t j% d(� g S # |j" $ rJ} t j d$| � �� t j d%|j d d& � d'�� g cY d } ~ S d } ~ ww xY w# t j& $ r t j d)� g cY S t j( $ r$} t j d*| � �� g cY d } ~ S d } ~ ww xY w)+z�
List all Windows applications with visible windows using PowerShell.
Returns list of window info dictionaries.
z;PowerShell not available - cannot list Windows applicationsa[
Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
using System.Text;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool IsWindowVisible(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsIconic(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsZoomed(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
[DllImport("user32.dll")]
public static extern int GetWindowTextLength(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
}
"@
$windows = @()
# Get processes with capturable windows only
Get-Process | Where-Object {
$_.MainWindowHandle -ne 0 -and $_.ProcessName -notmatch "^(dwm|csrss|winlogon|wininit)$"
} | ForEach-Object {
$handle = [IntPtr]$_.MainWindowHandle
$isVisible = [Win32]::IsWindowVisible($handle)
$isMinimized = [Win32]::IsIconic($handle)
$isMaximized = [Win32]::IsZoomed($handle)
# Only include windows that are in capturable states
# Skip hidden windows that can't be meaningfully captured
if (-not ($isVisible -or $isMinimized)) {
return # Skip this window
}
# Get window title using Windows API (more reliable than MainWindowTitle)
$titleLength = [Win32]::GetWindowTextLength($handle)
if ($titleLength -gt 0) {
$title = New-Object System.Text.StringBuilder($titleLength + 1)
[Win32]::GetWindowText($handle, $title, $title.Capacity) | Out-Null
$windowTitle = $title.ToString()
} else {
$windowTitle = $_.MainWindowTitle
}
# Include window even if title is empty, but provide useful info
if ([string]::IsNullOrEmpty($windowTitle)) {
$windowTitle = "[$($_.ProcessName) - $($_.Id)]"
}
# Determine window state - only capturable states
$windowState = if ($isMinimized) {
"minimized"
} elseif ($isMaximized) {
"maximized"
} else {
"normal"
}
$windows += @{
id = $_.MainWindowHandle.ToString()
title = $windowTitle
process_name = $_.ProcessName
process_id = $_.Id.ToString()
window_handle = $_.MainWindowHandle.ToString()
is_visible = $isVisible
is_minimized = $isMinimized
is_maximized = $isMaximized
window_state = $windowState
type = "windows"
}
}
# Convert to JSON
$windows | ConvertTo-Json -Compress
r/ r0 T� �utf-8�ignore�r3 r4 r5 r6 �encoding�errorsr N�
window_handle�0�id� �title� process_name�
process_id�
is_visibleF� is_minimized� is_maximized� window_state�normalr )
rH rJ rK rL rF rM rN rO rP �typezFound z, capturable windows using enhanced detectionc 3 �2 K � | ] }|d dk( s� d�� � y�w)rP rQ � N� ��.0�ws r" � <genexpr>z4WindowsWindowManager.list_windows.<locals>.<genexpr>� s � �� �*_���>�AR�V^�A^�1�*_�� �
�c 3 �2 K � | ] }|d dk( s� d�� � y�w)rP � minimizedrT NrU rV s r" rY z4WindowsWindowManager.list_windows.<locals>.<genexpr>� � � �� �-e�A�A�n�DU�Yd�Dd�a�-e�rZ c 3 �2 K � | ] }|d dk( s� d�� � y�w)rP � maximizedrT NrU rV s r" rY z4WindowsWindowManager.list_windows.<locals>.<genexpr>� r] rZ zWindow states: z normal, z minimized, z
maximizedz(Failed to parse PowerShell JSON output: zPowerShell output was: i� �...z6PowerShell returned empty output - no windows detectedz8PowerShell window enumeration timed out after 30 secondsz%Failed to list Windows applications: )r) r r; r8 r9 �json�stdout�strip�loads�
isinstance�dict�str�get�appendr7 �len�sum�JSONDecodeErrorr r: r< ) r+ � ps_scriptr> ra �datar � window_inforF � normal_count�minimized_count�maximized_countr! s r" � list_windowsz!WindowsWindowManager.list_windowsK s� � �
�(�(� �L�L�V� W��I�U �T�I�l �^�^�!�:�y�9� #���� � ��F�
��}�}�"�"�$�' � �:�:�f�m�m�&9�&9�&;�<�D�!�$��-� $�v�� �G�'+� � �(+�K�O�O�O�S�,Q�(R�
�(�C�/� $� ���"%�k�o�o�d�B�&?�"@�%0�_�_�W�b�%A�,7�O�O�N�B�,O�*-�k�o�o�l�B�.O�*P�-:�*5�/�/�,��*N�,7�O�O�N�E�,R�,7�O�O�N�E�,R�,7�O�O�N�H�,U�$-� (� ��( �K�K�&��W� ��6b� c�d� �'*�*_�g�*_�'_� �*-�-e��-e�*e��*-�-e��-e�*e�� � � �o�l�^�9�_�L]�]i�jy�iz� {E� %F� G�"�N� ��� W�X�� ��
�+�+� ��L�L�#K�A�3�!O�P��L�L�#:�6�=�=��#�;N�:O�s�!S�T� �I�� �� �(�(� � �L�L�S� T��I��,�,� � �L�L�@���D� E��I�� �sU �A I( �&FH �5I( � I%�?I �I%�I( � I%�%I( �(*K
�K
�&K�?K
�K
N� window_id� output_pathc � � | j s t d� � d|� d�}t j dd|gdddddd �
� }|j j � }|s t d � �| j
|� }|�&t t j � � }d
|� d|� d�}t j d||gd�� t j ddd|� d�gd�� t j d|� �� |S # t j $ r$ t j d� t d|� �� �t j $ r!}t j d|� d|� �� � d }~ww xY w)zE
Capture screenshot of a Windows application window.
z>PowerShell not available - cannot capture Windows applicationsz�
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
$windowHandle = [IntPtr]a?"
if ($windowHandle -eq 0) {
Write-Error "Invalid window handle"
exit 1
}
# Define comprehensive Windows API functions
Add-Type @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
[StructLayout(LayoutKind.Sequential)]
public struct RECT {
public int Left, Top, Right, Bottom;
}
// Window management APIs
[DllImport("user32.dll")]
public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
[DllImport("user32.dll")]
public static extern bool IsIconic(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
[DllImport("user32.dll")]
public static extern bool PrintWindow(IntPtr hWnd, IntPtr hdcBlt, uint nFlags);
[DllImport("user32.dll")]
public static extern bool SetLayeredWindowAttributes(IntPtr hWnd, uint crKey, byte bAlpha, uint dwFlags);
[DllImport("user32.dll")]
public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
[DllImport("user32.dll")]
public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
[DllImport("user32.dll")]
public static extern bool SetForegroundWindow(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
public static extern bool EnumChildWindows(IntPtr hWndParent, EnumChildProc lpEnumFunc, IntPtr lParam);
[DllImport("user32.dll")]
public static extern int GetClassName(IntPtr hWnd, System.Text.StringBuilder lpClassName, int nMaxCount);
[DllImport("user32.dll")]
public static extern IntPtr FindWindowEx(IntPtr hWndParent, IntPtr hWndChildAfter, string lpszClass, string lpszWindow);
[DllImport("user32.dll")]
public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern bool BringWindowToTop(IntPtr hWnd);
public delegate bool EnumChildProc(IntPtr hWnd, IntPtr lParam);
// Constants
public const int SW_HIDE = 0;
public const int SW_RESTORE = 9;
public const int SW_MINIMIZE = 6;
public const int SW_SHOW = 5;
public const int GWL_EXSTYLE = -20;
public const int WS_EX_LAYERED = 0x80000;
public const int LWA_ALPHA = 0x2;
public const uint PW_CLIENTONLY = 0x1;
public const uint PW_RENDERFULLCONTENT = 0x2;
// Windows Messages
public const uint WM_KEYDOWN = 0x0100;
public const uint WM_KEYUP = 0x0101;
public const uint WM_CHAR = 0x0102;
public const uint WM_COMMAND = 0x0111;
public const uint WM_VSCROLL = 0x0115;
// Virtual Key Codes
public const int VK_SPACE = 0x20;
public const int VK_PRIOR = 0x21; // Page Up
public const int VK_NEXT = 0x22; // Page Down
public const int VK_DOWN = 0x28; // Down Arrow
public const int VK_UP = 0x26; // Up Arrow
public const int VK_LEFT = 0x25; // Left Arrow
public const int VK_RIGHT = 0x27; // Right Arrow
}
"@
# Check if window is minimized and implement smart capture logic
$isMinimized = [Win32]::IsIconic($windowHandle)
$wasMinimized = $false
$originalExStyle = 0
try {
# Get window rectangle
$rect = New-Object Win32+RECT
$success = [Win32]::GetWindowRect($windowHandle, [ref]$rect)
if (-not $success) {
Write-Error "Could not get window rectangle"
exit 1
}
$width = $rect.Right - $rect.Left
$height = $rect.Bottom - $rect.Top
if ($width -le 0 -or $height -le 0) {
Write-Error "Invalid window dimensions: $($width)x$($height)"
exit 1
}
# Handle minimized windows with stealth restoration
if ($isMinimized) {
Write-Verbose "Window is minimized, using stealth restoration technique"
$wasMinimized = $true
# Make window transparent for stealth operation
$originalExStyle = [Win32]::GetWindowLong($windowHandle, [Win32]::GWL_EXSTYLE)
$newExStyle = $originalExStyle -bor [Win32]::WS_EX_LAYERED
[Win32]::SetWindowLong($windowHandle, [Win32]::GWL_EXSTYLE, $newExStyle) | Out-Null
[Win32]::SetLayeredWindowAttributes($windowHandle, 0, 1, [Win32]::LWA_ALPHA) | Out-Null
# Restore window temporarily
[Win32]::ShowWindow($windowHandle, [Win32]::SW_RESTORE) | Out-Null
Start-Sleep -Milliseconds 100 # Brief pause for window to render
# Update rectangle after restoration
$success = [Win32]::GetWindowRect($windowHandle, [ref]$rect)
if ($success) {
$width = $rect.Right - $rect.Left
$height = $rect.Bottom - $rect.Top
}
}
# Create bitmap for capture
$bitmap = New-Object System.Drawing.Bitmap($width, $height)
$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
# Try PrintWindow first (better for minimized/hidden windows)
$hdcBitmap = $graphics.GetHdc()
$printSuccess = [Win32]::PrintWindow($windowHandle, $hdcBitmap, [Win32]::PW_RENDERFULLCONTENT)
$graphics.ReleaseHdc($hdcBitmap)
# Fallback to CopyFromScreen if PrintWindow fails
if (-not $printSuccess) {
Write-Verbose "PrintWindow failed, falling back to CopyFromScreen"
if (-not $isMinimized) {
$graphics.CopyFromScreen($rect.Left, $rect.Top, 0, 0, [System.Drawing.Size]::new($width, $height))
} else {
throw "Cannot capture minimized window with CopyFromScreen"
}
}
$graphics.Dispose()
# Save to temporary file
$tempPath = [System.IO.Path]::GetTempFileName() + ".png"
$bitmap.Save($tempPath, [System.Drawing.Imaging.ImageFormat]::Png)
$bitmap.Dispose()
Write-Output $tempPath
} finally {
# Restore original window state if it was modified
if ($wasMinimized) {
# Restore original transparency
[Win32]::SetWindowLong($windowHandle, [Win32]::GWL_EXSTYLE, $originalExStyle) | Out-Null
# Re-minimize the window
[Win32]::ShowWindow($windowHandle, [Win32]::SW_MINIMIZE) | Out-Null
}
}
r/ r0 T�< rA rB rC �(PowerShell did not return temp file pathN�windows_capture_�_�.png�cp�r5 �
Remove-Item "�" -ForceFz Windows application captured: z4PowerShell window capture timed out after 60 secondszCapture timeout for window z&Failed to capture Windows application �: )r) r r8 r9 rb rc �_windows_path_to_wsl�int�timer r7 r: r; r< ) r+ rt ru rm r> �temp_windows_path�
wsl_temp_path� timestampr! s r" �capture_windowz#WindowsWindowManager.capture_window� s� � � �(�(�� \�]� ]�_ � %� &/�K� q0
� u�I�n �^�^�!�:�y�9� #���� � ��F� !'�
�
� 3� 3� 5� �$� � J�K�K� !� 5� 5�6G� H�M��"� �� � � � ,� � 0�� �1�Y�K�t� L� �
�N�N�D�-��=�T� J�
�N�N�!�:� �?P�>Q�QY�/Z�[��
�
�K�K�8��
�F� G� � ���(�(� G� �L�L�O� Q�� 9�)�� E�F� F��,�,� � �L�L�A�)��B�q�c�R� S� �� �s �CC0 �0AE�8 E�E� windows_pathc �0 � t j d|gdddd�� }|j j � S # t j t j
f$ r: |j
d� r$|j dd� j dd� cY S |cY S w xY w) z!Convert Windows path to WSL path.�wslpathT� r2 zC:z/mnt/c�\�/)r8 r9 rb rc r< r: �
startswith�replace)r+ r� r> s r" r� z)WindowsWindowManager._windows_path_to_wsl� s� � �
� �^�^��L�)� #���� �F� �=�=�&�&�(� (���-�-�z�/H�/H�I� ��&�&�t�,�#�+�+�D�(�;�C�C�D�#�N�N� � � �s �58 �AB�B�Bc � � | j s t d� �t j d� d}t j
dd|gdddd�� }|j j � }|s t d � �| j |� }|�#t t j � � }d |� d �}t j
d
||gd�� t j
ddd|� d�gd�� t j d|� �� |S # t j $ r! t j d� t d� �t j $ r }t j d|� �� � d
}~wt $ r }t j d|� �� � d
}~ww xY w)zL
Capture full screen screenshot using PowerShell from WSL2.
z5PowerShell not available - cannot capture full screenz)Capturing full screen using PowerShell...a3
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
# Get primary screen dimensions
$primaryScreen = [System.Windows.Forms.Screen]::PrimaryScreen
$bounds = $primaryScreen.Bounds
$width = $bounds.Width
$height = $bounds.Height
Write-Verbose "Screen dimensions: ${width}x${height}"
# Capture full screen
$bitmap = New-Object System.Drawing.Bitmap($width, $height)
$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
$graphics.CopyFromScreen(0, 0, 0, 0, [System.Drawing.Size]::new($width, $height))
$graphics.Dispose()
# Save to temporary file in Windows temp directory
$tempPath = [System.IO.Path]::GetTempFileName() + ".png"
$bitmap.Save($tempPath, [System.Drawing.Imaging.ImageFormat]::Png)
$bitmap.Dispose()
Write-Output $tempPath
r/ r0 Tr@ r2 rx N� fullscreen_r{ r| r} r~ r F�Full screen captured: z9PowerShell full screen capture timed out after 30 secondszFull screen capture timeout� Failed to capture full screen: z Full screen capture failed: )r) r r r7 r8 r9 rb rc r� r� r� r: r; r< )r+ ru rm r> r� r� r� r! s r" �capture_full_screenz(WindowsWindowManager.capture_full_screen� s� � � �(�(�� S�T� T�� � �?�@�D ��I�6 �^�^�!�:�y�9� #���� �F� !'�
�
� 3� 3� 5� �$� � J�K�K� !� 5� 5�6G� H�M��"� �� � � � ,� � +�I�;�d� ;� �
�N�N�D�-��=�T� J�
�N�N�!�:� �?P�>Q�QY�/Z�[��
�
�K�K�0��
�>� ?� � ���(�(� ;� �L�L�T� U�� 9�:� :��,�,� � �L�L�:�1�#�>� ?� ��� � �L�L�7��s�;� <� �� �s% �C
C< �<AF�E� F�&E?�?Fc � � | j g dg i d�}| j sd|d< |S t j g d�dddd�� }d |d
< |j j � d d d
z |d< d}t j dd|gddd�� }|j |d< |j |d< |j |d< |j j d� }|D ]� }|j d� r!t |j d� d � |d < �5|j d � r!t |j d� d � |d < �g|j d � s�yt |j d� d � |d < �� |S # t
$ r }dt
|� � �|d
< |cY d }~S d }~ww xY w# t
$ r}t
|� |d!< Y d }~|S d }~ww xY w)"z�
Comprehensive debugging information for window detection.
Returns detailed diagnostics about the PowerShell environment and window detection.
rI )r) �detection_methods�raw_powershell_output�parsing_errors� process_infozPowerShell not availabler; )r/ r0 z>Get-Process | Select-Object -First 5 Name, Id | ConvertTo-JsonTr1 r2 �SUCCESS�basic_powershell_testN�� r` �sample_processeszFAILED: a%
$VerbosePreference = "Continue"
Write-Verbose "Starting window detection debug..."
Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
using System.Text;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool IsWindowVisible(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsIconic(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsZoomed(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
[DllImport("user32.dll")]
public static extern int GetWindowTextLength(IntPtr hWnd);
}
"@
$allProcesses = Get-Process | Measure-Object | Select-Object -ExpandProperty Count
Write-Verbose "Total processes found: $allProcesses"
$processesWithWindows = Get-Process | Where-Object { $_.MainWindowHandle -ne 0 } | Measure-Object | Select-Object -ExpandProperty Count
Write-Verbose "Processes with windows: $processesWithWindows"
$windows = @()
Get-Process | Where-Object {
$_.MainWindowHandle -ne 0 -and $_.ProcessName -notmatch "^(dwm|csrss|winlogon|wininit)$"
} | ForEach-Object {
Write-Verbose "Processing: $($_.ProcessName) (ID: $($_.Id))"
$handle = [IntPtr]$_.MainWindowHandle
$isVisible = [Win32]::IsWindowVisible($handle)
$isMinimized = [Win32]::IsIconic($handle)
$isMaximized = [Win32]::IsZoomed($handle)
# Only include capturable windows (same logic as main script)
if (-not ($isVisible -or $isMinimized)) {
Write-Verbose "Skipping hidden window: $($_.ProcessName)"
return
}
$windows += @{
process_name = $_.ProcessName
process_id = $_.Id
window_handle = $_.MainWindowHandle.ToString()
main_window_title = $_.MainWindowTitle
is_visible = $isVisible
is_minimized = $isMinimized
is_maximized = $isMaximized
window_state = if ($isMinimized) { "minimized" } elseif ($isMaximized) { "maximized" } else { "normal" }
}
}
Write-Host "PROCESS_COUNT:$allProcesses"
Write-Host "WINDOWS_COUNT:$processesWithWindows"
Write-Host "FILTERED_COUNT:$($windows.Count)"
$windows | ConvertTo-Json -Depth 2
r/ r0 r@ )r3 r4 r6 �enhanced_script_exit_coder� �powershell_stderr�
zPROCESS_COUNT:�:rT �total_processeszWINDOWS_COUNT:�processes_with_windowszFILTERED_COUNT:�filtered_windows�enhanced_script_error) r) r8 r9 rb rc r rg �
returncode�stderr�splitr� r� )r+ �
debug_info�
basic_testr! � debug_scriptr> �lines�lines r" �debug_window_detectionz+WindowsWindowManager.debug_window_detection2 s� � � %)�$=�$=�!#�%'� � �
�
� �(�(�"<�J�w� � � � �#� � �p� #���� �J� 3<�J�.� /�-7�->�->�-D�-D�-F�t��-L�u�-T�J�)� *�[ 9�B �L�H �^�^�!�:�|�<� #��� �F� 7=�6G�6G�J�2� 3�28�-�-�J�.� /�.4�m�m�J�*� +� �M�M�'�'��-�E� �
M���?�?�#3�4�47��
�
�3���8J�4K�J� 0�1��_�_�%5�6�;>�t�z�z�#��q�?Q�;R�J� 7�8��_�_�%6�7�58����C� ��9K�5L�J� 1�2�
M� ���E � �4<�S��V�H�2E�J�.� /� � �� ��~ � 9�25�a�&�J�.� /���� 9�s= �AE2 �,C F �
"F �2 F�;F�
F�F� F=�$F8�8F=�parent_window_idc �r � | j st j d� |S d|� d|� d|� d�}t j dd|gdddd d
d � � }|j
j
� }|r#||k7 r t j d
|� d|� d�� |S t j d|� �� |S # t j $ r t j d� |cY S t j $ r$}t j d|� �� |cY d}~S d}~wt $ r$}t j d|� �� |cY d}~S d}~ww xY w)aC
Find the child window that handles PDF viewer functionality within Adobe Reader.
Args:
parent_window_id: Parent window handle ID (Adobe Reader main window)
Returns:
Child window handle ID that should receive navigation keys, or parent if not found
z9PowerShell not available - cannot enumerate child windowsz%
$parentHandle = [IntPtr]zF
if ($parentHandle -eq 0) {
Write-Output "a� "
exit 0
}
# Define Windows API functions for child window enumeration
Add-Type @"
using System;
using System.Runtime.InteropServices;
using System.Text;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool EnumChildWindows(IntPtr hWndParent, EnumChildProc lpEnumFunc, IntPtr lParam);
[DllImport("user32.dll")]
public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
[DllImport("user32.dll")]
public static extern IntPtr FindWindowEx(IntPtr hWndParent, IntPtr hWndChildAfter, string lpszClass, string lpszWindow);
[DllImport("user32.dll")]
public static extern bool IsWindowVisible(IntPtr hWnd);
public delegate bool EnumChildProc(IntPtr hWnd, IntPtr lParam);
}
"@
$foundWindows = @()
# Strategy 1: Look for common Adobe Reader PDF viewer window classes
$knownPDFClasses = @(
"AVPageView", # Adobe Reader page view
"AVScrolledPageView", # Adobe Reader scrolled view
"AcroRd32Class", # Adobe Reader document
"AcrobatClass", # Adobe Acrobat document
"AVL_AVView", # Adobe Viewer
"AVPageViewWnd32", # Adobe page view window
"AVThumbnailView" # Adobe thumbnail view
)
foreach ($className in $knownPDFClasses) {
$childHandle = [Win32]::FindWindowEx($parentHandle, [IntPtr]::Zero, $className, $null)
if ($childHandle -ne [IntPtr]::Zero -and [Win32]::IsWindowVisible($childHandle)) {
Write-Verbose "Found PDF viewer window with class: $className"
$foundWindows += $childHandle.ToString()
}
}
# Strategy 2: Enumerate all child windows and look for likely candidates
$allChildWindows = @()
# Define callback function for EnumChildWindows
$callback = {
param($hWnd, $lParam)
$className = New-Object System.Text.StringBuilder(256)
$result = [Win32]::GetClassName($hWnd, $className, $className.Capacity)
if ($result -gt 0) {
$class = $className.ToString()
$isVisible = [Win32]::IsWindowVisible($hWnd)
# Look for classes that might contain PDF content
if ($isVisible -and ($class -match "(View|Page|Document|PDF|Acro|AVL)" -or $class.Length -gt 10)) {
$allChildWindows += @{
Handle = $hWnd.ToString()
ClassName = $class
IsVisible = $isVisible
}
}
}
return $true # Continue enumeration
}
# This won't work directly in PowerShell due to delegate limitations
# But we'll try the FindWindowEx approach which is more reliable
# Strategy 3: Try to find the most likely candidate window
# Look for windows with specific patterns in class names
$candidateHandle = [IntPtr]::Zero
$childAfter = [IntPtr]::Zero
do {
$childAfter = [Win32]::FindWindowEx($parentHandle, $childAfter, $null, $null)
if ($childAfter -ne [IntPtr]::Zero) {
$className = New-Object System.Text.StringBuilder(256)
$result = [Win32]::GetClassName($childAfter, $className, $className.Capacity)
if ($result -gt 0) {
$class = $className.ToString()
$isVisible = [Win32]::IsWindowVisible($childAfter)
# Prioritize windows with PDF-related class names
if ($isVisible -and ($class -match "(AVPageView|AVScrolled|AcroRd|Acrobat|AVL_AVView)" -or
($class.Length -gt 8 -and $class -notmatch "(Button|Static|Edit|ComboBox|ListBox)"))) {
$foundWindows += $childAfter.ToString()
Write-Verbose "Found candidate window: $class ($($childAfter.ToString()))"
}
}
}
} while ($childAfter -ne [IntPtr]::Zero)
# Return the best candidate or the parent if none found
if ($foundWindows.Count -gt 0) {
# Return the first likely PDF viewer window
Write-Output $foundWindows[0]
} else {
# Fallback to parent window
Write-Output "z "
}
r/ r0 T� rA rB rC z Found PDF viewer child window: z
(parent: �)z9No suitable PDF viewer child window found, using parent: z>PowerShell child window enumeration timed out after 15 secondsz#Failed to enumerate child windows: Nz,Unexpected error finding PDF viewer window: ) r) r r; r8 r9 rb rc r7 r: r< r )r+ r� rm r> �child_window_idr! s r" �_find_pdf_viewer_windowz,WindowsWindowManager._find_pdf_viewer_window� s[ � � �(�(� �L�L�T� U�#� #�P $� %�%5�$6� 7 � /� 0� m1 �Z 0� 0� 1
�ar�I�h �^�^�!�:�y�9� #���� � ��F� %�m�m� 1� 1� 3�O� �?�6F�#F�� � � =�o�=N�j�Yi�Xj�jk� l�m�&�&�� � � W�Xh�Wi� j�k�'�'���(�(� $� �L�L�Y� Z�#� #��,�,� $� �L�L�>�q�c�B� C�#� #��� $� �L�L�G��s�K� L�#� #�� $�s< �A)B) �B) �)*D6�D6�'D� D6� D6�D1�+D6�1D6�keyc �� � | j st j d� y | j |� }t j d|� d|� d�� d|� d|� d|� d �}t j d
d |gd d d d
dd�� }d|j v sd|j v r t j d|� d|� �� y t j d|� d|� �� t j d|j � �� y# t
j $ r t j d� Y yt
j $ r%}t j d|� d|� �� Y d}~yd}~wt $ r"}t j d|� �� Y d}~yd}~ww xY w)a�
Send a key press to a specific window using PostMessage for direct window messaging.
First tries to find PDF viewer child window, then sends key directly via Windows API.
Args:
window_id: Window handle ID
key: Key to send (e.g., "{DOWN}", "{PGDN}", "{RIGHT}")
Returns:
True if key was sent successfully, False otherwise
z+PowerShell not available - cannot send keysFz Target window for key sending: z (original: r� z%
$targetHandle = [IntPtr]aO
if ($targetHandle -eq 0) {
Write-Error "Invalid target window handle"
exit 1
}
# Define comprehensive Windows API functions
Add-Type @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool SetForegroundWindow(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool BringWindowToTop(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
[DllImport("user32.dll")]
public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern bool IsWindow(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsWindowVisible(IntPtr hWnd);
// Windows Messages
public const uint WM_KEYDOWN = 0x0100;
public const uint WM_KEYUP = 0x0101;
public const uint WM_CHAR = 0x0102;
// Virtual Key Codes
public const int VK_SPACE = 0x20;
public const int VK_PRIOR = 0x21; // Page Up
public const int VK_NEXT = 0x22; // Page Down
public const int VK_DOWN = 0x28; // Down Arrow
public const int VK_UP = 0x26; // Up Arrow
public const int VK_LEFT = 0x25; // Left Arrow
public const int VK_RIGHT = 0x27; // Right Arrow
public const int SW_RESTORE = 9;
public const int SW_SHOW = 5;
}
"@
# Validate target window
if (-not [Win32]::IsWindow($targetHandle)) {
Write-Error "Target window handle is not valid"
exit 1
}
# Map SendKeys format to virtual key codes
$virtualKey = 0
switch ("a� ") {
"{DOWN}" { $virtualKey = [Win32]::VK_DOWN }
"{PGDN}" { $virtualKey = [Win32]::VK_NEXT }
"{RIGHT}" { $virtualKey = [Win32]::VK_RIGHT }
"{UP}" { $virtualKey = [Win32]::VK_UP }
"{LEFT}" { $virtualKey = [Win32]::VK_LEFT }
" " { $virtualKey = [Win32]::VK_SPACE }
default {
# Try to handle other keys - fallback to space
$virtualKey = [Win32]::VK_NEXT # Default to Page Down for PDF navigation
}
}
if ($virtualKey -eq 0) {
Write-Error "Unknown key mapping for: a� "
exit 1
}
try {
# Send key messages directly to target window (no window state changes needed)
$keyDownResult = [Win32]::PostMessage($targetHandle, [Win32]::WM_KEYDOWN, [IntPtr]$virtualKey, [IntPtr]0)
Start-Sleep -Milliseconds 50
$keyUpResult = [Win32]::PostMessage($targetHandle, [Win32]::WM_KEYUP, [IntPtr]$virtualKey, [IntPtr]0)
if ($keyDownResult -and $keyUpResult) {
Write-Output "SUCCESS: PostMessage sent VK=$virtualKey to window $($targetHandle.ToString())"
} else {
Write-Warning "PostMessage may have failed: KeyDown=$keyDownResult KeyUp=$keyUpResult"
# Fallback: try SendMessage instead of PostMessage
[Win32]::SendMessage($targetHandle, [Win32]::WM_KEYDOWN, [IntPtr]$virtualKey, [IntPtr]0) | Out-Null
Start-Sleep -Milliseconds 50
[Win32]::SendMessage($targetHandle, [Win32]::WM_KEYUP, [IntPtr]$virtualKey, [IntPtr]0) | Out-Null
Write-Output "FALLBACK: SendMessage used as fallback"
}
} catch {
Write-Error "Failed to send key message: $($_.Exception.Message)"
exit 1
}
r/ r0 Tr� rA rB rC r� �FALLBACKzSuccessfully sent key 'z' to target window zFailed to send key 'zPowerShell output: z:PowerShell enhanced key sending timed out after 15 secondsz' using PostMessage: Nz*Unexpected error in enhanced key sending: ) r) r r; r� �debugr8 r9 rb r: r< r )r+ rt r� �target_window_idrm r> r! s r" �_send_key_to_windowz(WindowsWindowManager._send_key_to_windowS s� � � �(�(� �L�L�F� G��F � #� ;� ;�I� F� � �L�L�:�;K�:L�L�Yb�Xc�cd�e� f� %�%5�$6� ;7�v �U� 7� 8;�e� <
�Ud�I�L �^�^�!�:�y�9� #���� � ��F� �F�M�M�)�Z�6�=�=�-H�� � � 6�s�e�;N�O_�N`� a�b��� � � 3�C�5�8K�L\�K]� ^�_�� � � 2�6�=�=�/� B�C� ���(�(� � �L�L�U� W���,�,� � �L�L�/��u�4I�!��M� N���� � �L�L�E�a�S�I� J��� �s0 �BC2 �4=C2 �2(E<� E<�.E� E<�E7�7E<�
page_count�
output_dir�navigation_key�
delay_secondsc � � t � }|� |j � rd}nt � }n t |� }j dd�� t |� }ddddd d
d d d
�} | j ||� }
t j d|� d|� �� t j d|� d|
� d|� d�� | j |� } t j d| � �� g } t d|dz � D ]� }
t j d|
� d|� �� t |
� }||z } | j |t |� � }| j |� t j d|
� d|� �� |
|k s�|t j d|
� �� | j! ||
� }|st j# d |
� �� t% j& |� �� t j d t) | � � d |� �� | r*| j+ || � t j d | � �� | S # t $ r&}t j d|
� d|� �� Y d}~��Sd}~ww xY w# t $ r�}d t- � v r\ rZ | j+ || � t j d!| � �� n.# t $ r"}t j# d"|� �� Y d}~nd}~ww xY wt j d#|� �� � d}~ww xY w)$a�
Capture multiple pages from a document window with automatic navigation.
Args:
window_id: Window ID containing the document
page_count: Number of pages to capture
output_dir: Directory to save captured pages
navigation_key: Key to send for navigation (e.g., "{DOWN}", "{PGDN}", "{RIGHT}")
delay_seconds: Delay between navigation and capture
Returns:
List of captured file paths
N�capturesT��parents�exist_ok�{DOWN}z{PGDN}z{RIGHT}z{UP}z{LEFT}� z{ENTER}z{TAB})�Down� Page_Down�Right�Up�Left�space�Enter�Tabz Starting multi-page capture: z pages from window zNavigation key: z -> z , Delay: �szOriginal window state: rT zCapturing page r� zCaptured page r� zFailed to capture page z#Navigating to next page using key: z'Failed to send navigation key for page z Multi-page capture completed: z pages captured to z#Restored window to original state: �original_window_statez#Restored window state after error: z,Failed to restore window state after error: �"Failed to capture multiple pages: )r �should_use_legacy_moder
�mkdirrg rh r r7 � _detect_and_prepare_window_state�ranger r� ri r r; r� r� r r� �sleeprj �_restore_window_state�locals)r+ rt r� r� r� r� �config�actual_output_dir�output_dir_str� key_mapping�sendkeys_formatr� �captured_files�page_num�filenameru �
captured_pathr! �key_sent�
restore_errors r" �capture_multiple_pagesz+WindowsWindowManager.capture_multiple_pages� s� � �"T � �\�F��!��0�0�2�!+�J�(<�(>�%�$8��$D�!�
� #� #�D�4� #� @� �!2� 3�N� !� %�"� � � �"� � �K� *�o�o�n�n� M�O�
�K�K�7�
�|�CV�W`�Va�b� c� �K�K�*�>�*:�$��>O�y�Yf�Xg�gh�i� j�$(�$I�$I�)�$T� !� �K�K�1�2G�1H�I� J� �N� !�!�Z�!�^� 4�
.��� � �o�h�Z�q�� � E�F� 2�(�;�� /�(� :� � �$(�$7�$7� �3�{�CS�$T�M�"�)�)�-�8��K�K�.��
�"�]�O� L�M� �j�(��L�L�#F��FW�!X�Y� #� 7� 7� �?� S�H�#� ���)P�QY�PZ�'[�\� �J�J�}�-�1
.�4
�K�K�8��^�9L�8M�M`�ar�`s�t� u� %��*�*�9�6K�L�� � � A�BW�AX� Y�Z�!� !��/ !� ��L�L�#:�8�*�B�q�c�!J�K� �� ��2 �
�&�&�(�2�7L�c��.�.�y�:O�P��K�K�"E�F[�E\� ]�^�� � c��N�N�%Q�R_�Q`�#a�b�b��c��
�L�L�=�a�S�A� B� ��
�st �DI �AH� I �"B,I � H>�H9�3I �9H>�>I � K�
K �*J�K � J/�
J*�%K �*J/�/ K � Kc � � | j st j d� i S d|� d�}t j dd|gdddddd �
� }|j
j
� }|d v rt j d |� �� i S |j d
� }t |� dk\ rD|d |d dk( |d dk( |d dk( |d dk( |d dk( d�}t j d|� �� |S t j d|� �� i S # t j $ r t j d� i cY S t j $ r$}t j d|� �� i cY d}~S d}~wt $ r$}t j d |� �� i cY d}~S d}~ww xY w) a-
Detect current window state and prepare for capture session.
Only modifies window state if necessary for capture operations.
Args:
window_id: Window handle ID
Returns:
Dictionary with original window state information
z5PowerShell not available - cannot detect window state�%
$windowHandle = [IntPtr]a-
if ($windowHandle -eq 0) {
Write-Output "invalid_handle"
exit 0
}
# Define Windows API functions for state detection
Add-Type @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool IsWindow(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsWindowVisible(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsIconic(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool IsZoomed(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
[DllImport("user32.dll")]
public static extern bool SetForegroundWindow(IntPtr hWnd);
[DllImport("user32.dll")]
public static extern bool BringWindowToTop(IntPtr hWnd);
public const int SW_RESTORE = 9;
public const int SW_SHOW = 5;
public const int SW_MINIMIZE = 6;
public const int SW_MAXIMIZE = 3;
}
"@
if (-not [Win32]::IsWindow($windowHandle)) {
Write-Output "invalid_window"
exit 0
}
# Detect current state
$isVisible = [Win32]::IsWindowVisible($windowHandle)
$isMinimized = [Win32]::IsIconic($windowHandle)
$isMaximized = [Win32]::IsZoomed($windowHandle)
$isForeground = ([Win32]::GetForegroundWindow() -eq $windowHandle)
# Determine state name
$stateName = if ($isMinimized) {
"minimized"
} elseif ($isMaximized) {
"maximized"
} elseif ($isVisible) {
"normal"
} else {
"hidden"
}
# Determine if we need to prepare the window for capture
$needsPreparation = $false
if ($isMinimized -or -not $isVisible) {
Write-Verbose "Window needs preparation: restoring from minimized/hidden state"
$needsPreparation = $true
# Only restore if minimized or hidden
[Win32]::ShowWindow($windowHandle, [Win32]::SW_RESTORE) | Out-Null
Start-Sleep -Milliseconds 200
}
if (-not $isForeground) {
Write-Verbose "Window needs focus preparation"
$needsPreparation = $true
# Only set focus if not already foreground
[Win32]::BringWindowToTop($windowHandle) | Out-Null
[Win32]::SetForegroundWindow($windowHandle) | Out-Null
Start-Sleep -Milliseconds 100
}
# Output state information
Write-Output "$stateName|$isVisible|$isMinimized|$isMaximized|$isForeground|$needsPreparation"
r/ r0 Tr1 rA rB rC )�invalid_handle�invalid_windowz$Invalid window for state detection: �|� r rT �True� � � r� )�
state_name� was_visible�
was_minimized�
was_maximized�was_foreground� was_preparedzDetected window state: z Could not parse window state: z Window state detection timed outz Failed to detect window state: Nz,Unexpected error in window state detection: )r) r r r8 r9 rb rc r� rj r� r: r; r< r )r+ rt rm r> �output�parts�
state_infor! s r" r� z5WindowsWindowManager._detect_and_prepare_window_stateR s� � � �(�(� �N�N�R� S��I�E � %�%.�K� X0
�Y�I�v �^�^�!�:�y�9� #���� � ��F� �]�]�(�(�*�F��=�=����!E�f�X� N�O�� � �L�L��%�E��5�z�Q��"'��(�#(��8�v�#5�%*�1�X��%7�%*�1�X��%7�&+�A�h�&�&8�$)�!�H��$6�
�
� � � � 6�z�l� C�D�!�!����!?��x� H�I�� ���(�(� � �L�L�;� <��I��,�,� � �L�L�:�1�#�>� ?��I��� � �L�L�G��s�K� L��I�� �sC �A C? �A"C? �%C? �?*F �+F �=E �F � F �(F�F �F �original_statec
�@ � | j r|sy |j dd� st j d� yd|� dt |j dd� � j � � dt |j d d� � j � � d
t |j d d� � j � � d � }t
j d
d|gdddddd�� }d|j v rt j d� yt j d� y# t j $ r t j d� Y yt j $ r"}t j d|� �� Y d}~yd}~wt $ r"}t j d|� �� Y d}~yd}~ww xY w)a:
Restore window to its original state after capture session.
Args:
window_id: Window handle ID
original_state: State information from _detect_and_prepare_window_state
Returns:
True if restoration was successful, False otherwise
Fr� z7No window state changes were made, skipping restorationTr� a�
if ($windowHandle -eq 0) {
exit 1
}
# Define Windows API functions
Add-Type @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
public const int SW_RESTORE = 9;
public const int SW_MINIMIZE = 6;
public const int SW_MAXIMIZE = 3;
public const int SW_HIDE = 0;
}
"@
$wasMinimized = [bool]::Parse("r� z.")
$wasMaximized = [bool]::Parse("r� z,")
$wasVisible = [bool]::Parse("r� aG ")
# Restore original window state
if ($wasMinimized) {
Write-Verbose "Restoring to minimized state"
[Win32]::ShowWindow($windowHandle, [Win32]::SW_MINIMIZE) | Out-Null
} elseif ($wasMaximized) {
Write-Verbose "Restoring to maximized state"
[Win32]::ShowWindow($windowHandle, [Win32]::SW_MAXIMIZE) | Out-Null
} elseif (-not $wasVisible) {
Write-Verbose "Restoring to hidden state"
[Win32]::ShowWindow($windowHandle, [Win32]::SW_HIDE) | Out-Null
} else {
Write-Verbose "Restoring to normal state"
[Win32]::ShowWindow($windowHandle, [Win32]::SW_RESTORE) | Out-Null
}
Write-Output "SUCCESS"
r/ r0 r� rA rB rC r� z"Successfully restored window statez Failed to restore window statez"Window state restoration timed outz Failed to restore window state: Nz.Unexpected error in window state restoration: )r) rh r r� rg r r8 r9 rb r r: r; r< r )r+ rt r� rm r> r! s r" r� z*WindowsWindowManager._restore_window_state� s� � � �(�(���J �!�%�%�n�e�<�� � � V�W�� %�%.�K� 0,�( -0��0B�0B�?�TY�0Z�,[�,a�,a�,c�+d� e,�,/��0B�0B�?�TY�0Z�,[�,a�,a�,c�+d� e*�*-�n�.@�.@� �PT�.U�*V�*\�*\�*^�)_� `
�/)�I�V �^�^�!�:�y�9� #���� � ��F� �F�M�M�)�� � � A�B����� ?�@� ���(�(� � �L�L�=� >���,�,� � �L�L�;�A�3�?� @���� � �L�L�I�!��M� N��� �s5 �'D �CD � D �(F � F �E/�/ F �;F�F r' )Nr� g �?)�__name__�
__module__� __qualname__�__doc__r, �boolr( r r rg rs r r� r� r� �anyr� r� r� r� �floatr� rf r� r� rU r- r" r% r% 1 sY � �S�=��4� �(^�d�4��S��>� 2� ^�@f�� f�(�3�-� f�SV� f�P �� �� �"L�x��}� L�� L�\��S�#�X�� �B^$�� ^$�� ^$�@V�S� V�s� V�t� V�r :>�3;�47�e�� e�� e�)1�#� �e�-0�e� -2�e� =A��I�e�NT�#� T�$� T�lX�s� X�D� X�T� Xr- r% c � � e Zd ZdZd� Zd� Zdeeeef fd�Z d dede
e defd �Z d de
e defd
�Z deeef fd �Z
y)
�CrossPlatformWindowManagerz{
Unified interface that automatically selects the appropriate window manager
based on the runtime environment.
c �L � t � | _ | j � | _ y r' )r# � environment�_create_manager�managerr* s r" r, z#CrossPlatformWindowManager.__init__I s � �-�/����+�+�-�� r- c �R � | j dk( rLt � }|j rt j d� |S t j d� t � S | j dk( r t j d� t � S t j d� t � S )z7Create appropriate window manager based on environment.r z8Using Windows application manager (PowerShell from WSL2)z9PowerShell unavailable, falling back to Linux X11 managerr z!Using Windows application managerz Using Linux X11 window manager)r r% r) r r7 �
WindowCapture)r+ �windows_managers r" r z*CrossPlatformWindowManager._create_managerM s� � � � � �u� $� 2� 4�O� �3�3�� � � V�W�&�&�� � � W�X�$��&�
�
�
��
*� �K�K�;� <�'�)� )� �K�K�8� 9� �?� "r- r c � � | j j � }|D ]6 }| j |d< d|vs�| j dk( rdn | j |d< �8 |S # t $ r$}t j d|� �� g cY d}~S d}~ww xY w)z9List all available windows using the appropriate manager.r rR r �x11zFailed to list windows: N)r rs r r r r; )r+ r �windowr! s r" rs z'CrossPlatformWindowManager.list_windows_ s� � � ��l�l�/�/�1�G� "�
`��(,�(8�(8��}�%���'�.2�.>�.>�'�.I�U�t�O_�O_�F�6�N�
`�
�N��� � �L�L�3�A�3�7� 8��I�� �s" �2A �#A � B�"B�;B�BNrt ru c �: � | j j ||� S )z(Capture screenshot of a specific window.)r r� )r+ rt ru s r" r� z)CrossPlatformWindowManager.capture_windowo s � ��|�|�*�*�9�k�B�Br- c � � t | j d� r| j j |� S t j � }|�#t t
j � � }d|� d�}|j |� t j d|� �� |S # t $ r }t j d|� �� � d}~ww xY w)z Capture full screen screenshot.r� N� screenshot_r{ r� r� ) �hasattrr r� � ImageGrab�grabr� r� �saver r7 r r; �r+ ru �
screenshotr� r! s r" r� z.CrossPlatformWindowManager.capture_full_screens s� � � �4�<�<�!6� 7��<�<�3�3�K�@� @�
� &�^�^� -�
� �&� #�D�I�I�K� 0�I�$/� �{�$�"?�K���� �,�� � � 4�[�M� B�C�"�"�� �
�� � � >�q�c� B�C���
�s �A#B � B>� B9�9B>c �< � | j t | j � j d�}t | j t
� r| j j |d< |S t | j t � r t � }||d< t |� dk( |d< |S )z?Get information about the current environment and capabilities.)r � manager_typer) �missing_dependenciesr �
x11_available)
r rR r r� re r% r) r �check_dependenciesrj )r+ r7 � missing_depss r" �get_environment_infoz/CrossPlatformWindowManager.get_environment_info� s� � � �+�+� �� � � .� 7� 7�
��
�d�l�l�$8� 9�+/�<�<�+L�+L�D�'� (� � � �� � �m�
4�-�/�L�+7�D�'� (�$'� �$5��$:�D� � !�� r- r' )r� r� r� r� r, r r r rg rs r r� r� r rU r- r" r r C sx � ��
.�#�$�d�4��S��>� 2� � C�� C�(�3�-� C�SV� C��x��}� �� �*�d�3��8�n� r- r c �� � e Zd ZdZd� Zdeeeef fd�Zdede e
e e e e f fd�Z dede
fd�Zdd e e defd
�Zdded e e defd �Z dded e d
e e dededee f d�Zdedede
fd�Zy)r z;Handles window enumeration and screenshot capture on Linux.c �N � t j j dd� | _ y )N�DISPLAYz:0)r �environrh �displayr* s r" r, zWindowCapture.__init__� s � ��z�z�~�~�i��6�� r- r c � � t j ddgdddd�� }g }|j j � j d� D ]^ }|j � s�|j dd� }t |� d k\ s�5|d
}|d }|d }|d }|j
||||d
�� �` |S # t j $ r$} t j d| � �� g cY d} ~ S d} ~ wt $ r t j d� g cY S w xY w)zt
List all available windows using wmctrl command.
Returns list of window info dictionaries.
�wmctrlz-lTr1 r2 r� Nr� r� r rT r� )rH rJ �desktop�machinez$Failed to list windows with wmctrl: z=wmctrl not found. Please install: sudo apt-get install wmctrl) r8 r9 rb rc r� rj ri r< r r; r= )
r+ r> r r� r� rt r# r$ rJ r! s
r" rs zWindowCapture.list_windows� s � �
" � �^�^��4� � #���� �F� �G� �
�
�+�+�-�3�3�D�9�
���:�:�<� �J�J�t�Q� /�E��5�z�Q��$)�!�H� �"'��(��"'��(�� %�a��� ���"+�%*�'.�'.� (� �
� �N���,�,� � �L�L�?��s�C� D��I�� � � �L�L�X� Y��I� �s0 �AB, � B, �>-B, �,D�?C �D� #D�Drt c �� � t j ddgdddd�� }|j j � j d� D ]r }|j |� s�|j � }t
|� dk\ s�4t |d � }t |d � }t |d
� }t |d � }||||fc S y # t j t f$ r"} t j d
| � �� Y d } ~ y d } ~ ww xY w)zL
Get window geometry (x, y, width, height) for a window ID.
r" z-GTr1 r2 r� � r� r� r� r� Nz Failed to get window geometry: ) r8 r9 rb rc r� r� rj r� r< �
ValueErrorr r; )
r+ rt r> r� r� �x�y�width�heightr! s
r" �get_window_geometryz!WindowCapture.get_window_geometry� s� � � � �^�^��4� � #���� �F� �
�
�+�+�-�3�3�D�9�
5���?�?�9�-� �J�J�L�E��5�z�Q�� ��a��M�� ��a��M�� #�E�!�H�
��!$�U�1�X� �� !�1�e�V� 4�4�
5� ���-�-�z�:� � �L�L�:�1�#�>� ?��� �s* �AB= � B= �;?B= �;B= �=C8�C3�3C8c �� � t j ddd|gddd�� t j d� y# t j $ r%}t
j
d|� d |� �� Y d
}~y d
}~ww xY w) z+
Focus a window by its ID.
r" z-iz-aTr� �r5 r3 r6 g �?zFailed to focus window r� NF)r8 r9 r� r� r< r r; )r+ rt r! s r" � focus_windowzWindowCapture.focus_window� sk � � � �N�N��4��y�1�� #��
�
�J�J�s�O����,�,� � �L�L�2�9�+�R��s�C� D��� �s �25 �A-�A(�(A-Nru c � � t j � }|�#t t j � � }d|� d�}|j |� t
j
d|� �� |S # t $ r }t
j d|� �� � d}~ww xY w)z1
Capture full screen screenshot.
Nr r{ r� r� ) r r r� r� r r r7 r r; r s r" r� z!WindowCapture.capture_full_screen� s� � �
�"� � �)�J��"� �� � � � ,� � +�I�;�d� ;� � �O�O�K� (� �K�K�0��
�>� ?� � ��� � �L�L�:�1�#�>� ?� �� �s �A#A& �& B
�/B�B
c �( � | j |� st j d|� d�� | j |� }|r(|\ }}}}t j
||||z ||z f�� }n-t j d|� d�� t j
� }|�&t
t j � � } d|� d| � d �}|j |� t j d
|� �� |S # t $ r!}
t j d |� d |
� �� � d}
~
ww xY w)
z:
Capture screenshot of a specific window.
�Could not focus window z, trying capture anyway)�bboxz"Could not get geometry for window z, capturing full screenN�window_rz r{ zWindow captured: zFailed to capture window r� ) r/ r r r, r r r� r� r r7 r r; ) r+ rt ru �geometryr( r) r* r+ r r� r! s r" r� z WindowCapture.capture_window
s � � ��$�$�Y�/����!8�� �CZ� [�\� �/�/� �:�H��&.�#��1�e�V� &�^�^�!�Q��E� �1�v�:�1N� O�
����!C�I�;�Ne� f�g� &�^�^� -�
��"� �� � � � ,� � '� �{�!�I�;�d� C� � �O�O�K� (� �K�K�+�K�=�9� :� � ��� � �L�L�4�Y�K�r�!��E� F� �� �s �C$C' �' D�0 D � Dr� r� r� r� c � � t � }|� |j � rd}nt � }n t |� }j dd�� | j |� st d|� �� �g }t
d|dz � D ]t } t | � }
||
z } | j |t | � � |j t | � � | |k s�N| j ||� t j |� �v t j dt! |� � d|� �� |S # t
$ r } t j# d | � �� � d} ~ ww xY w)
a�
Capture multiple pages from a document window.
Args:
window_id: Window to capture
page_count: Number of pages to capture
output_dir: Directory to save captures
navigation_key: Key to press for page navigation (Page_Down, Right, space)
delay_seconds: Delay between page navigation and capture
Returns:
List of captured file paths
Nr� Tr� r2 rT z Captured z
pages to r� )r r� r
r� r/ r r� r r� rg ri r� r� r� r r7 rj r; )
r+ rt r� r� r� r� r� r� r� r� r� ru r! s
r" r� z$WindowCapture.capture_multiple_pages* sB � �"% � �\�F��!��0�0�2�!+�J�(<�(>�%�$8��$D�!�
� #� #�D�4� #� @� �$�$�Y�/� �"9�)�� E�F�F� �N� !�!�Z�!�^� 4�
.��1�(�;�� /�(� :� ��#�#�I�s�;�/?�@� �%�%�c�+�&6�7� �j�(��,�,�Y��G��J�J�}�-�
.�
�K�K�)�C��$7�#8�
�CT�BU�V� W�!� !��� � �L�L�=�a�S�A� B� �� �s �CD �AD � D>� D9�9D>r� c �� � t j ddd||gddd�� y# t j $ r(}t j d|� d|� d |� �� Y d
}~y d
}~wt
$ r t j d � Y y w xY w)
zF
Send a key press to a specific window using xdotool.
�xdotoolr� z--windowTr� r. zFailed to send key z to window r� NFz?xdotool not found. Please install: sudo apt-get install xdotool)r8 r9 r< r r; r= )r+ rt r� r! s r" r� z!WindowCapture._send_key_to_windowb s� � � � �N�N��E�:�y�#�>�� #��
� ���,�,� � �L�L�.�s�e�;�y�k��A�3�O� P��� � � �L�L�Z� [�� �s � ! �A;� A�!A;�:A;r' )Nr� g �?)r� r� r� r� r, r r rg rs r r r� r, r� r/ r� r� r� r� r� rU r- r" r r � s� � �E�7�'�d�4��S��>� 2� '�R�S� �X�e�C��c�SV�DV�>W�5X� �:�c� �d� �$�x��}� �� �& �� �(�3�-� �SV� �B :>�3>�47�6�� 6�� 6�)1�#� �6�-0�6� -2�6� =A��I�6�p�S� �s� �t� r- r c �x � g } t j ddgddd�� t j ddgddd�� | S # t j t t j f$ r | j d� Y �Yw xY w# t j t t j f$ r | j d� Y | S w xY w)zh
Check if required system dependencies are installed.
Returns list of missing dependencies.
r" z --versionTr� )r3 r5 r6 r8 )r8 r9 r< r= r: ri )�missings r" r r w s� � �
�G�!�����+�.�t�4�YZ�[�
"���� �;�/��D�Z[�\� �N��
� )� )�+<�j�>W�>W� X� !����x� �!��
� )� )�+<�j�>W�>W� X� "����y�!� �N�"�s �= �A< �9A9�8A9�<9B9�8B9) r� r r8 r� r �typingr r r r �pathlibr � pyscreenshotr �PILr �loggingr� r r
r � getLoggerr� r rg r# r% r r r rU r- r" �<module>rA s� ���
� � � � .� .� � � � � K� K� �� � �8� $���C� �:O� O�d(S� S�l[� [�|�D��I� r-
