ok-script 0.0.42__tar.gz → 0.0.44__tar.gz

{ok-script-0.0.42 → ok-script-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.42
+Version: 0.0.44
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking
@@ -11,14 +11,16 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: adbutils==2.7.1
-Requires-Dist: numpy==1.26.4
-Requires-Dist: PyDirectInput==1.0.4
-Requires-Dist: pywin32==306
-Requires-Dist: typing-extensions==4.11.0
-Requires-Dist: PySide6==6.7.0
-Requires-Dist: PySide6-Fluent-Widgets==1.5.6
-Requires-Dist: opencv-python==4.9.0.80
+Requires-Dist: adbutils>=2.7.2
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: PyDirectInput>=1.0.4
+Requires-Dist: pywin32>=306
+Requires-Dist: typing-extensions>=4.11.0
+Requires-Dist: PySide6>=6.7.0
+Requires-Dist: PySide6-Fluent-Widgets>=1.5.6
+Requires-Dist: psutil>=5.9.8
+Requires-Dist: opencv-python>=4.9.0.80
+Requires-Dist: ok-d3dshot>=0.1.5
 
 # ok-script
 

{ok-script-0.0.42 → ok-script-0.0.44}/ok/OK.py

@@ -132,8 +132,8 @@ class OK:
         if self.device_manager is None:
             from ok.capture.adb.DeviceManager import DeviceManager
             self.device_manager = DeviceManager(self.config.get("config_folder") or "config",
-                                                self.config.get('capture_window_title'),
-                                                self.config.get('capture_window_exe_name'),
+                                                self.config.get('windows_capture'),
+                                                self.config.get('adb_capture'),
                                                 self.config.get("debug"),
                                                 self.exit_event)
             ok.gui.device_manager = self.device_manager

{ok-script-0.0.42 → ok-script-0.0.44}/ok/capture/BaseCaptureMethod.py

@@ -18,9 +18,26 @@ class BaseCaptureMethod:
         # Some capture methods don't need an initialization process
         pass
 
+    @property
+    def width(self):
+        if self._size[0] == 0:
+            self.get_frame()
+        return self._size[0]
+
+    @property
+    def height(self):
+        if self._size[1] == 0:
+            self.get_frame()
+        return self._size[1]
+
     def get_frame(self) -> np.ndarray | None:
         try:
-            return self.do_get_frame()
+            frame = self.do_get_frame()
+            if frame is not None:
+                self._size = (frame.shape[1], frame.shape[0])
+            if frame.shape[2] == 4:
+                frame = frame[:, :, :3]
+            return frame
         except Exception as e:
             raise CaptureException() from e
 

{ok-script-0.0.42 → ok-script-0.0.44}/ok/capture/HwndWindow.py

@@ -1,10 +1,9 @@
 # original https://github.com/dantmnf & https://github.com/hakaboom/winAuto
-import ctypes
-import os
 import re
 import threading
 import time
 
+import psutil
 import win32process
 from win32 import win32gui
 
@@ -28,6 +27,8 @@ class HwndWindow:
     right_cut = 0
     bottom_cut = 0
     left_cut = 0
+    ext_left_bounds = 0  # for BitBlt
+    ext_top_bounds = 0  # for BitBlt
     window_change_listeners = []
     frame_aspect_ratio = 0
     hwnd = None
@@ -35,13 +36,14 @@ class HwndWindow:
     frame_height = 0
     exists = False
     title = None
+    exe_full_path = None
 
-    def __init__(self, exit_event, title="", exe_name=None, frame_width=0, frame_height=0):
+    def __init__(self, exit_event, title, exe_name=None, frame_width=0, frame_height=0):
         super().__init__()
         self.app_exit_event = exit_event
         self.exe_name = exe_name
+        self.title = title
         self.stop_event = threading.Event()
-        self.update_title_re(title)
         self.visible = False
         self.update_frame_size(frame_width, frame_height)
         self.do_update_window_size()
@@ -49,7 +51,7 @@ class HwndWindow:
         self.thread.start()
 
     def update_title_and_exe(self, title, exe):
-        self.update_title_re(title)
+        self.title = title
         self.exe_name = exe
         self.hwnd = None
         self.visible = False
@@ -61,12 +63,6 @@ class HwndWindow:
     def stop(self):
         self.stop_event.set()
 
-    def update_title_re(self, title):
-        if not title:
-            self.title = None
-        else:
-            self.title = re.compile(title)
-
     def update_frame_size(self, width, height):
         logger.debug(f"update_frame_size:{self.frame_width}x{self.frame_height} to {width}x{height}")
         if width != self.frame_width or height != self.frame_height:
@@ -82,24 +78,22 @@ class HwndWindow:
             time.sleep(0.2)
 
     def get_abs_cords(self, x, y):
-        return int(self.x * self.scaling + (self.border * self.scaling + x)), int(
-            self.y * self.scaling + (y + self.title_height * self.scaling))
+        return self.x + self.border + x, self.y + y + self.title_height
 
     def get_top_left_frame_offset(self):
-        return int(self.border * self.scaling), int(
-            self.title_height * self.scaling)
+        return self.border, self.title_height
 
     def do_update_window_size(self):
         try:
-            visible, x, y, border, title_height, width, height, scaling = self.visible, self.x, self.y, self.border, self.title_height, self.width, self.height, self.scaling
+            visible, x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = self.visible, self.x, self.y, self.border, self.title_height, self.width, self.height, self.scaling, self.ext_left_bounds, self.ext_top_bounds
             if self.hwnd is None:
-                self.hwnd = find_hwnd_by_title_and_exe(self.title, self.exe_name)
+                self.hwnd, self.exe_full_path = find_hwnd_by_title_and_exe(self.title, self.exe_name)
                 self.exists = self.hwnd is not None
             if self.hwnd is not None:
                 self.exists = win32gui.IsWindow(self.hwnd)
                 if self.exists:
                     visible = is_foreground_window(self.hwnd)
-                    x, y, border, title_height, width, height, scaling = get_window_bounds(
+                    x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
                         self.hwnd)
                     if self.frame_aspect_ratio != 0 and height != 0:
                         window_ratio = width / height
@@ -117,10 +111,10 @@ class HwndWindow:
                     self.visible = visible
                     self.scaling = scaling
                     changed = True
-                if (
-                        x != self.x or y != self.y or border != self.border or title_height != self.title_height or width != self.width or height != self.height or scaling != self.scaling) and (
-                        (x >= 0 and y >= 0) or self.visible):
-                    self.x, self.y, self.border, self.title_height, self.width, self.height = x, y, border, title_height, width, height
+                if (ext_left_bounds != self.ext_left_bounds or ext_top_bounds != self.ext_top_bounds or
+                    x != self.x or y != self.y or border != self.border or title_height != self.title_height or width != self.width or height != self.height or scaling != self.scaling) and (
+                        (x >= -1 and y >= -1) or self.visible):
+                    self.x, self.y, self.border, self.title_height, self.width, self.height, self.ext_left_bounds, self.ext_top_bounds = x, y, border, title_height, width, height, ext_left_bounds, ext_top_bounds
                     changed = True
                 if changed:
                     logger.debug(
@@ -141,9 +135,14 @@ class HwndWindow:
             return win32gui.GetWindowText(self.hwnd)
         return ""
 
+    def __str__(self) -> str:
+        return f"title:{self.title},exe:{self.exe_name},width:{self.width},height:{self.height},exists:{self.exists},visible:{self.visible}"
+
 
 def find_hwnd_by_title_and_exe(title, exe_name):
     result = []
+    if title is None and exe_name is None:
+        return None, None
 
     def callback(hwnd, lParam):
         if len(result) == 0 and win32gui.IsWindowVisible(hwnd) and win32gui.IsWindowEnabled(hwnd):
@@ -154,42 +153,26 @@ def find_hwnd_by_title_and_exe(title, exe_name):
                         return True
                 elif not re.search(title, text):
                     return True
+            name, full_path = get_exe_by_hwnd(hwnd)
             if exe_name:
-                name = get_exe_name_by_hwnd(hwnd)
                 if name == exe_name:
-                    result.append(hwnd)
+                    result.append((hwnd, full_path))
                     return True  # Stop enumeration as we found the first match
             else:
-                result.append(hwnd)
+                result.append((hwnd, full_path))
         return True
 
     win32gui.EnumWindows(callback, None)
-    return result[0] if result else None
-
-
-OpenProcess = ctypes.windll.kernel32.OpenProcess
-CloseHandle = ctypes.windll.kernel32.CloseHandle
-GetModuleFileNameExW = ctypes.windll.psapi.GetModuleFileNameExW
+    if result:
+        return result[0][0], result[0][1]
+    else:
+        return None, None
 
-PROCESS_QUERY_INFORMATION = 0x0400
-PROCESS_VM_READ = 0x0010
 
-
-def get_exe_name_by_hwnd(hwnd):
-    # Get the process ID of the window
+def get_exe_by_hwnd(hwnd):
+    # Get the process ID associated with the window
     _, pid = win32process.GetWindowThreadProcessId(hwnd)
 
-    # Open the process
-    h_process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, pid)
-    if h_process:
-        # Get the executable name
-        exe_name = ctypes.create_unicode_buffer(1024)
-        GetModuleFileNameExW(h_process, None, exe_name, 1024)
-
-        # Extract the executable name from the full path
-        exe_only_name = os.path.basename(exe_name.value)
-
-        # Close the process handle
-        CloseHandle(h_process)
-
-        return exe_only_name
+    # Get the process name and executable path
+    process = psutil.Process(pid)
+    return process.name(), process.exe()

{ok-script-0.0.42 → ok-script-0.0.44}/ok/capture/adb/ADBCaptureMethod.py

@@ -19,18 +19,6 @@ class ADBCaptureMethod(BaseCaptureMethod):
         self._connected = (width != 0 and height != 0)
         self.device_manager = device_manager
 
-    @property
-    def width(self):
-        if self._size[0] == 0:
-            self.screencap()
-        return self._size[0]
-
-    @property
-    def height(self):
-        if self._size[1] == 0:
-            self.screencap()
-        return self._size[1]
-
     @override
     def do_get_frame(self) -> np.ndarray | None:
         return self.screencap()
@@ -38,11 +26,9 @@ class ADBCaptureMethod(BaseCaptureMethod):
     def screencap(self):
         if self.exit_event.is_set():
             return None
-        frame = do_screencap(self.device_manager)
+        frame = do_screencap(self.device_manager.device)
         if frame is not None:
-            height, width, _ = frame.shape
             self._connected = True
-            self._size = (width, height)
         else:
             self._connected = False
         return frame
@@ -53,8 +39,10 @@ class ADBCaptureMethod(BaseCaptureMethod):
         return self._connected and self.device_manager.device is not None
 
 
-def do_screencap(device_manager) -> np.ndarray | None:
-    png_bytes = device_manager.shell("screencap -p", encoding=None)
+def do_screencap(device) -> np.ndarray | None:
+    if device is None:
+        return None
+    png_bytes = device.shell("screencap -p", encoding=None)
     if png_bytes is not None and len(png_bytes) > 0:
         image_data = np.frombuffer(png_bytes, dtype=np.uint8)
         image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)

{ok-script-0.0.42 → ok-script-0.0.44}/ok/capture/adb/DeviceManager.py

@@ -1,13 +1,12 @@
 import threading
 
-import adbutils
 import win32gui
 from adbutils import AdbError
 
 from ok.capture.HwndWindow import HwndWindow, find_hwnd_by_title_and_exe
 from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod, do_screencap
+from ok.capture.adb.WindowsCaptureFactory import update_capture_method
 from ok.capture.adb.vbox import installed_emulator
-from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
 from ok.capture.windows.window import get_window_bounds
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -20,22 +19,24 @@ logger = get_logger(__name__)
 
 class DeviceManager:
 
-    def __init__(self, config_folder, hwnd_title=None, exe_name=None, debug=False, exit_event=None):
+    def __init__(self, config_folder, windows_capture_config, adb_capture_config, debug=False, exit_event=None):
         self._device = None
         self._connect_all = False
-        self.adb = self.adb = adbutils.AdbClient(host="127.0.0.1")
-        logger.debug(f'connect adb')
-        self.hwnd_title = hwnd_title
+        self._adb = None
+        self.windows_capture_config = windows_capture_config
+        self.adb_capture_config = adb_capture_config
         self.pc_device = None
-        self.exe_name = exe_name
         self.debug = debug
         self.interaction = None
         self.exit_event = exit_event
-        if hwnd_title is not None:
-            self.hwnd = HwndWindow(exit_event, hwnd_title, exe_name)
-        self.config = Config({"devices": {}, "preferred": "none"}, config_folder, "DeviceManager")
+        if windows_capture_config is not None:
+            self.hwnd = HwndWindow(exit_event, windows_capture_config.get('title'),
+                                   windows_capture_config.get('exe'))
+        self.config = Config({"devices": {}, "preferred": "none", "pc_full_path": None}, config_folder,
+                             "DeviceManager")
         self.thread = None
         self.capture_method = None
+        self.update_pc_device()
         self.start()
 
     def refresh(self):
@@ -46,6 +47,8 @@ class DeviceManager:
     @property
     def device_dict(self):
         device_dict = self.config.get("devices")
+        if device_dict is None:
+            device_dict = {}
         if self.pc_device is not None:
             full = {'pc': self.pc_device}
             full.update(device_dict)
@@ -53,6 +56,14 @@ class DeviceManager:
         else:
             return device_dict
 
+    @property
+    def adb(self):
+        if self._adb is None:
+            import adbutils
+            self._adb = adbutils.AdbClient(host="127.0.0.1")
+            logger.debug(f'connect adb')
+        return self._adb
+
     def connect_all(self):
         if not self._connect_all:
             for device in self.device_dict.values():
@@ -67,49 +78,62 @@ class DeviceManager:
     def get_devices(self):
         return list(self.device_dict.values())
 
-    def do_refresh(self):
-
-        if self.hwnd_title:
+    def update_pc_device(self):
+        if self.windows_capture_config is not None:
             nick = ""
             width = 0
             height = 0
-            hwnd = find_hwnd_by_title_and_exe(self.hwnd_title, self.exe_name)
+            hwnd, full_path = find_hwnd_by_title_and_exe(self.windows_capture_config.get('title'),
+                                                         self.windows_capture_config.get('exe'))
             if hwnd is not None:
                 nick = win32gui.GetWindowText(hwnd)
-                _, _, _, _, width, height, _ = get_window_bounds(
+                _, _, _, _, width, height, _, _, _ = get_window_bounds(
                     hwnd)
             if not nick:
-                nick = self.exe_name
+                nick = self.windows_capture_config.get('exe')
             self.pc_device = {"address": "", "imei": 'pc', "device": "windows",
                               "model": "", "nick": nick, "width": width,
                               "height": height,
                               "hwnd": nick, "capture": "windows",
-                              "connected": hwnd is not None
+                              "connected": hwnd is not None,
+                              "full_path": full_path or self.config.get('pc_full_path')
                               }
+            if full_path and full_path != self.config.get('pc_full_path'):
+                self.config['pc_full_path'] = full_path
+
             if width != 0:
                 self.pc_device["resolution"] = f"{width}x{height}"
             communicate.adb_devices.emit(False)
 
-        self.connect_all()
+    def do_refresh(self, fast=False):
+        self.update_pc_device()
+
+        self.refresh_adb_device(fast)
+
+        if self.exit_event.is_set():
+            return
+        self.start()
+        communicate.adb_devices.emit(True)
+        logger.debug(f'refresh {self.device_dict}')
 
-        installed_emulators = installed_emulator()
+    def refresh_adb_device(self, fast):
+        if self.adb_capture_config is None:
+            return
+        if not fast:
+            self.connect_all()
+        installed_emulators = [] if fast else installed_emulator()
         for device in self.adb.list():
             logger.debug(f'adb.list() {device}')
-
         for emulator in installed_emulators:
             logger.debug(f"installed_emulator: {emulator}")
-            self.adb.connect(emulator.adb_address)
-
+            self.adb.connect(emulator.adb_address, timeout=1)
         device_list = self.adb.device_list()
-
         device_list = sorted(device_list, key=lambda x: x.serial)
-
         adb_connected = []
-
         for device in device_list:
             imei = device.shell("settings get secure android_id") or device.shell(
                 "service call iphonesubinfo 4") or device.prop.model
-            frame = do_screencap(device)
+            frame = None if fast else do_screencap(device)
             width, height = 0, 0
             if frame is not None:
                 height, width, _ = frame.shape
@@ -128,23 +152,27 @@ class DeviceManager:
                     old_hwnd = self.device_dict[imei].get("hwnd")
                     self.device_dict[imei] = adb_device
                     if old_capture is not None:
-                        self.device_dict[imei]['capture'] = old_capture
+                        self.update_device_value(imei, 'capture', old_capture)
                     if old_hwnd is not None:
-                        self.device_dict[imei]['hwnd'] = old_hwnd
+                        self.update_device_value(imei, 'hwnd', old_hwnd)
             else:
-                self.device_dict[imei] = adb_device
+                self.update_device(imei, adb_device)
             adb_connected.append(imei)
         for imei in self.device_dict:
-            if imei not in adb_connected and self.device_dict[imei]['device'] == 'adb':
-                self.device_dict[imei]['connected'] = False
-
+            if self.device_dict[imei]['device'] == 'adb':
+                self.update_device_value(imei, 'connected', imei in adb_connected)
         self.config.save_file()
 
-        if self.exit_event.is_set():
-            return
-        self.start()
-        communicate.adb_devices.emit(True)
-        logger.debug(f'refresh {self.device_dict}')
+    def update_device(self, imei, device=None):
+        devices = self.config.get("devices", {})
+        devices[imei] = device
+        self.config["devices"] = devices
+
+    def update_device_value(self, imei, key, value):
+        devices = self.config.get("devices", {})
+        if imei in devices:
+            devices[imei][key] = value
+        self.config["devices"] = devices
 
     def set_preferred_device(self, imei=None):
         logger.debug(f"set_preferred_device {imei}")
@@ -191,6 +219,16 @@ class DeviceManager:
             self.hwnd.update_frame_size(frame_width, frame_height)
             self.hwnd.update_title_and_exe(title, exe)
 
+    def use_windows_capture(self, override_config=None, require_bg=False):
+        if not override_config:
+            override_config = self.windows_capture_config
+        self.capture_method = update_capture_method(override_config, self.capture_method, self.hwnd,
+                                                    require_bg)
+        if self.capture_method is None:
+            logger.error(f'can find a usable windows capture')
+        else:
+            logger.info(f'capture method {type(self.capture_method)}')
+
     def start(self):
         preferred = self.get_preferred_device()
         if preferred is None:
@@ -199,14 +237,11 @@ class DeviceManager:
             return
 
         if preferred['device'] == 'windows':
-            self.ensure_hwnd(self.hwnd_title, self.exe_name)
-            if not isinstance(self.capture_method, WindowsGraphicsCaptureMethod):
-                if self.capture_method is not None:
-                    self.capture_method.close()
-                self.capture_method = WindowsGraphicsCaptureMethod(self.hwnd)
+            self.ensure_hwnd(self.windows_capture_config.get('title'), self.windows_capture_config.get('exe'))
+            self.use_windows_capture()
             if not isinstance(self.interaction, Win32Interaction):
                 self.interaction = Win32Interaction(self.capture_method)
-            self.capture_method.hwnd_window = self.hwnd
+            preferred['connected'] = self.capture_method.connected()
         else:
             self.connect_all()
             for adb_device in self.adb.device_list():
@@ -218,11 +253,9 @@ class DeviceManager:
             height = preferred.get('height', 0)
             if preferred.get('capture') == "windows":
                 self.ensure_hwnd(hwnd_name, None, width, height)
-                if not isinstance(self.capture_method, WindowsGraphicsCaptureMethod):
-                    if self.capture_method is not None:
-                        self.capture_method.close()
-                    self.capture_method = WindowsGraphicsCaptureMethod(self.hwnd)
-                self.capture_method.hwnd_window = self.hwnd
+                if self.hwnd.exe_full_path:
+                    self.update_device_value(preferred['imei'], 'full_path', self.hwnd.exe_full_path)
+                self.use_windows_capture({'can_bit_blt': True}, require_bg=True)
             elif not isinstance(self.capture_method, ADBCaptureMethod):
                 if self.capture_method is not None:
                     self.capture_method.close()
@@ -271,3 +304,11 @@ class DeviceManager:
                 return device.shell(*args, **kwargs)
         else:
             raise Exception('Device is none')
+
+    def get_exe_path(self, device):
+        path = device.get('full_path')
+        if device.get('device') == 'windows' and self.windows_capture_config and self.windows_capture_config.get(
+                'calculate_pc_exe_path'):
+            return self.windows_capture_config.get('calculate_pc_exe_path')(path)
+        else:
+            return path

ok-script-0.0.44/ok/capture/adb/WindowsCaptureFactory.py

@@ -0,0 +1,39 @@
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def update_capture_method(config, capture_method, hwnd, require_bg=False):
+    if config.get('can_bit_blt'):
+        logger.debug(
+            f"try BitBlt method {config} current_type:{type(capture_method)}")
+        from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
+        target_method = BitBltCaptureMethod
+        capture_method = get_capture(capture_method, target_method, hwnd)
+        if capture_method.test_exclusive_full_screen():
+            return capture_method
+        else:
+            logger.info("test_exclusive_full_screen failed, can't use BitBlt")
+    from ok.capture.windows.WindowsGraphicsCaptureMethod import windows_graphics_available
+    if windows_graphics_available():
+        from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
+        target_method = WindowsGraphicsCaptureMethod
+        capture_method = get_capture(capture_method, target_method, hwnd)
+        return capture_method
+
+    if not require_bg:
+        from ok.capture.windows.DesktopDuplicationCaptureMethod import DesktopDuplicationCaptureMethod
+        target_method = DesktopDuplicationCaptureMethod
+        capture_method = get_capture(capture_method, target_method, hwnd)
+        return capture_method
+
+    return None
+
+
+def get_capture(capture_method, target_method, hwnd):
+    if not isinstance(capture_method, target_method):
+        if capture_method is not None:
+            capture_method.close()
+        capture_method = target_method(hwnd)
+    capture_method.hwnd_window = hwnd
+    return capture_method

{ok-script-0.0.42 → ok-script-0.0.44}/ok/capture/adb/vbox.py

@@ -3,7 +3,6 @@
 import winreg
 from dataclasses import dataclass
 
-import adbutils
 import win32com.client
 
 from ok.capture.adb.targets import ADBControllerTarget
@@ -122,20 +121,3 @@ def installed_emulator():
     except Exception as e:
         logger.error(f'failed to check server :{server} {e}', e)
     return results
-
-
-def _main():
-    logger.config({'debug': True})
-    adb = adbutils.AdbClient(host="127.0.0.1", port=5037)
-    for x in installed_emulator():
-        logger.debug(f'installed emulators {x}')
-        adb.connect(x.adb_address)
-
-    logger.debug(adb.device_list())
-    for device in adb.device_list():
-        logger.debug(device.shell('settings get secure android_id'))
-        logger.debug(f'{device.info}')
-
-
-if __name__ == '__main__':
-    _main()

ok-script-0.0.44/ok/capture/windows/BaseWindowsCaptureMethod.py

@@ -0,0 +1,36 @@
+# original https://github.com/dantmnf & https://github.com/hakaboom/winAuto
+import ctypes.wintypes
+
+from ok.capture.BaseCaptureMethod import BaseCaptureMethod
+from ok.capture.HwndWindow import HwndWindow
+from ok.logging.Logger import get_logger
+
+PBYTE = ctypes.POINTER(ctypes.c_ubyte)
+WGC_NO_BORDER_MIN_BUILD = 20348
+
+logger = get_logger(__name__)
+
+
+class BaseWindowsCaptureMethod(BaseCaptureMethod):
+    _hwnd_window: HwndWindow = None
+
+    def __init__(self, hwnd_window: HwndWindow):
+        super().__init__()
+        self._hwnd_window = hwnd_window
+
+    @property
+    def hwnd_window(self):
+        return self._hwnd_window
+
+    @hwnd_window.setter
+    def hwnd_window(self, hwnd_window):
+        self._hwnd_window = hwnd_window
+
+    def connected(self):
+        return self.hwnd_window is not None and self.hwnd_window.exists
+
+    def get_abs_cords(self, x, y):
+        return self.hwnd_window.get_abs_cords(x, y)
+
+    def clickable(self):
+        return self.hwnd_window is not None and self.hwnd_window.visible