UIA Control Detection

def __new__(cls, backend: str = "uia") -> "ControlInspectorFacade":
    """
    Singleton pattern.
    """
    if backend not in cls._instances:
        instance = super().__new__(cls)
        instance.backend = backend
        instance.backend_strategy = BackendFactory.create_backend(backend)
        cls._instances[backend] = instance
    return cls._instances[backend]

def find_control_elements_in_descendants(
    self,
    window: UIAWrapper,
    control_type_list: List[str] = [],
    class_name_list: List[str] = [],
    title_list: List[str] = [],
    is_visible: bool = True,
    is_enabled: bool = True,
    depth: int = 0,
) -> List[UIAWrapper]:
    """
    Find control elements in descendants of the window.
    :param window: The window to find control elements.
    :param control_type_list: The control types to find.
    :param class_name_list: The class names to find.
    :param title_list: The titles to find.
    :param is_visible: Whether the control elements are visible.
    :param is_enabled: Whether the control elements are enabled.
    :param depth: The depth of the descendants to find.
    :return: The control elements found.
    """
    if self.backend == "uia":
        return self.backend_strategy.find_control_elements_in_descendants(
            window, control_type_list, [], title_list, is_visible, is_enabled, depth
        )
    elif self.backend == "win32":
        return self.backend_strategy.find_control_elements_in_descendants(
            window, [], class_name_list, title_list, is_visible, is_enabled, depth
        )
    else:
        return []

@staticmethod
def get_application_root_name(window: UIAWrapper) -> str:
    """
    Get the application name of the window.
    :param window: The window to get the application name.
    :return: The root application name of the window. Empty string ("") if failed to get the name.
    """
    if window == None:
        return ""
    process_id = window.process_id()
    try:
        process = psutil.Process(process_id)
        return process.name()
    except psutil.NoSuchProcess:
        return ""

@staticmethod
def get_check_state(control_item: auto.Control) -> bool | None:
    """
    get the check state of the control item
    param control_item: the control item to get the check state
    return: the check state of the control item
    """
    is_checked = None
    is_selected = None
    try:
        assert isinstance(
            control_item, auto.Control
        ), f"{control_item =} is not a Control"
        is_checked = (
            control_item.GetLegacyIAccessiblePattern().State
            & auto.AccessibleState.Checked
            == auto.AccessibleState.Checked
        )
        if is_checked:
            return is_checked
        is_selected = (
            control_item.GetLegacyIAccessiblePattern().State
            & auto.AccessibleState.Selected
            == auto.AccessibleState.Selected
        )
        if is_selected:
            return is_selected
        return None
    except Exception as e:
        # print(f'item {control_item} not available for check state.')
        # print(e)
        return None

@staticmethod
def get_control_info(
    window: UIAWrapper, field_list: List[str] = []
) -> Dict[str, str]:
    """
    Get control info of the window.
    :param window: The window to get control info.
    :param field_list: The fields to get.
    return: The control info of the window.
    """
    control_info: Dict[str, str] = {}

    def assign(prop_name: str, prop_value_func: Callable[[], str]) -> None:
        if len(field_list) > 0 and prop_name not in field_list:
            return
        control_info[prop_name] = prop_value_func()

    try:
        assign("control_type", lambda: window.element_info.control_type)
        assign("control_id", lambda: window.element_info.control_id)
        assign("control_class", lambda: window.element_info.class_name)
        assign("control_name", lambda: window.element_info.name)
        rectangle = window.element_info.rectangle
        assign(
            "control_rect",
            lambda: (
                rectangle.left,
                rectangle.top,
                rectangle.right,
                rectangle.bottom,
            ),
        )
        assign("control_text", lambda: window.element_info.name)
        assign("control_title", lambda: window.window_text())
        assign("selected", lambda: ControlInspectorFacade.get_check_state(window))

        try:
            source = window.element_info.source
            assign("source", lambda: source)
        except:
            assign("source", lambda: "")

        return control_info
    except:
        return {}

def get_control_info_batch(
    self, window_list: List[UIAWrapper], field_list: List[str] = []
) -> List[Dict[str, str]]:
    """
    Get control info of the window.
    :param window_list: The list of windows to get control info.
    :param field_list: The fields to get.
    return: The list of control info of the window.
    """
    control_info_list = []
    for window in window_list:
        control_info_list.append(self.get_control_info(window, field_list))
    return control_info_list

def get_control_info_list_of_dict(
    self, window_dict: Dict[str, UIAWrapper], field_list: List[str] = []
) -> List[Dict[str, str]]:
    """
    Get control info of the window.
    :param window_dict: The dict of windows to get control info.
    :param field_list: The fields to get.
    return: The list of control info of the window.
    """
    control_info_list = []
    for key in window_dict.keys():
        window = window_dict[key]
        control_info = self.get_control_info(window, field_list)
        control_info["label"] = key
        control_info_list.append(control_info)
    return control_info_list

def get_desktop_app_dict(self, remove_empty: bool = True) -> Dict[str, UIAWrapper]:
    """
    Get all the apps on the desktop and return as a dict.
    :param remove_empty: Whether to remove empty titles.
    :return: The apps on the desktop as a dict.
    """
    desktop_windows = self.get_desktop_windows(remove_empty)

    desktop_windows_with_gui = []

    for window in desktop_windows:
        try:
            window.is_normal()
            desktop_windows_with_gui.append(window)
        except:
            pass

    desktop_windows_dict = dict(
        zip(
            [str(i + 1) for i in range(len(desktop_windows_with_gui))],
            desktop_windows_with_gui,
        )
    )
    return desktop_windows_dict

def get_desktop_app_info(
    self,
    desktop_windows_dict: Dict[str, UIAWrapper],
    field_list: List[str] = ["control_text", "control_type"],
) -> List[Dict[str, str]]:
    """
    Get control info of all the apps on the desktop.
    :param desktop_windows_dict: The dict of apps on the desktop.
    :param field_list: The fields of app info to get.
    :return: The control info of all the apps on the desktop.
    """
    desktop_windows_info = self.get_control_info_list_of_dict(
        desktop_windows_dict, field_list
    )
    return desktop_windows_info

def get_desktop_windows(self, remove_empty: bool = True) -> List[UIAWrapper]:
    """
    Get all the apps on the desktop.
    :param remove_empty: Whether to remove empty titles.
    :return: The apps on the desktop.
    """
    return self.backend_strategy.get_desktop_windows(remove_empty)