windows-mcp 0.5.9__py3-none-any.whl → 0.6.1__py3-none-any.whl

windows_mcp/uia/core.py

@@ -101,6 +101,10 @@ class _AutomationClient:
         return cls._instance
 
     def __init__(self):
+        try:
+            ctypes.windll.ole32.CoInitialize(None)
+        except Exception:
+            pass
         tryCount = 3
         for retry in range(tryCount):
             try:
@@ -111,62 +115,9 @@ class _AutomationClient:
                 break
             except Exception as ex:
                 if retry + 1 == tryCount:
-                    Logger.WriteLine('''
-{}
-Can not load UIAutomationCore.dll.
-1, You may need to install Windows Update KB971513 if your OS is Windows XP, see https://github.com/yinkaisheng/WindowsUpdateKB971513ForIUIAutomation
-2, You need to use an UIAutomationInitializerInThread object if use uiautomation in a thread, see demos/uiautomation_in_thread.py'''.format(ex), ConsoleColor.Yellow)
                     raise ex
 
 
-class _DllClient:
-    _instance = None
-
-    @classmethod
-    def instance(cls) -> '_DllClient':
-        """Singleton instance (this prevents com creation on import)."""
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    def __init__(self):
-        binPath = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
-        os.environ["PATH"] = binPath + os.pathsep + os.environ["PATH"]
-        load = False
-        if IsPy38OrHigher and IsNT6orHigher:
-            os.add_dll_directory(binPath)
-        if CurrentProcessIs64Bit:
-            try:
-                self.dll = ctypes.cdll.UIAutomationClient_VC140_X64
-                load = True
-            except Exception as ex:
-                print(ex)
-        else:
-            try:
-                self.dll = ctypes.cdll.UIAutomationClient_VC140_X86
-                load = True
-            except Exception as ex:
-                print(ex)
-        if load:
-            self.dll.BitmapCreate.restype = ctypes.c_size_t
-            self.dll.BitmapGetWidthAndHeight.restype = ctypes.c_uint64
-            self.dll.BitmapFromWindow.restype = ctypes.c_size_t
-            self.dll.BitmapFromHBITMAP.restype = ctypes.c_size_t
-            self.dll.BitmapToHBITMAP.restype = ctypes.c_size_t
-            self.dll.BitmapFromFile.restype = ctypes.c_size_t
-            self.dll.BitmapFromBytes.restype = ctypes.c_size_t
-            self.dll.BitmapResize.restype = ctypes.c_size_t
-            self.dll.BitmapRotate.restype = ctypes.c_size_t
-            self.dll.BitmapGetPixel.restype = ctypes.c_uint32
-            self.dll.Initialize()
-        else:
-            self.dll = None
-            Logger.WriteLine('Can not load dll.\nFunctionalities related to Bitmap are not available.\nYou may need to install Microsoft Visual C++ 2015 Redistributable Package.', ConsoleColor.Yellow)
-
-    def __del__(self):
-        if self.dll:
-            self.dll.Uninitialize()
-
 
 # set Windows dll restype
 ctypes.windll.user32.GetAncestor.restype = ctypes.c_void_p
@@ -178,7 +129,6 @@ ctypes.windll.user32.GetWindowLongW.restype = ctypes.wintypes.LONG
 ctypes.windll.user32.OpenDesktopW.restype = ctypes.c_void_p
 ctypes.windll.user32.SendMessageW.restype = ctypes.wintypes.LONG
 ctypes.windll.user32.WindowFromPoint.restype = ctypes.c_void_p
-ctypes.windll.gdi32.CreateBitmap.restype = ctypes.c_void_p
 ctypes.windll.gdi32.CreateCompatibleDC.restype = ctypes.c_void_p
 ctypes.windll.gdi32.SelectObject.restype = ctypes.c_void_p
 ctypes.windll.kernel32.GetConsoleWindow.restype = ctypes.c_void_p
@@ -188,7 +138,6 @@ ctypes.windll.kernel32.GlobalLock.restype = ctypes.c_void_p
 ctypes.windll.kernel32.OpenProcess.restype = ctypes.c_void_p
 ctypes.windll.ntdll.NtQueryInformationProcess.restype = ctypes.c_uint32
 
-
 def _GetDictKeyName(theDict: Dict[str, Any], theValue: Any, keyCondition: Optional[Callable[[str], bool]] = None) -> str:
     for key, value in theDict.items():
         if keyCondition:
@@ -588,6 +537,21 @@ def GetVirtualScreenSize() -> Tuple[int, int]:
     return w, h
 
 
+def GetVirtualScreenRect() -> Tuple[int, int, int, int]:
+    """Returns (left, top, width, height) of the virtual screen."""
+    SM_XVIRTUALSCREEN = 76
+    SM_YVIRTUALSCREEN = 77
+    SM_CXVIRTUALSCREEN = 78
+    SM_CYVIRTUALSCREEN = 79
+    return (
+        ctypes.windll.user32.GetSystemMetrics(SM_XVIRTUALSCREEN),
+        ctypes.windll.user32.GetSystemMetrics(SM_YVIRTUALSCREEN),
+        ctypes.windll.user32.GetSystemMetrics(SM_CXVIRTUALSCREEN),
+        ctypes.windll.user32.GetSystemMetrics(SM_CYVIRTUALSCREEN)
+    )
+
+
+
 def GetMonitorsRect() -> List[Rect]:
     """
     Get monitors' rect.
@@ -1765,837 +1729,6 @@ def _ExitHandler():
 atexit.register(_ExitHandler)
 
 
-class RotateFlipType:
-    RotateNoneFlipNone = 0
-    Rotate90FlipNone = 1
-    Rotate180FlipNone = 2
-    Rotate270FlipNone = 3
-    RotateNoneFlipX = 4
-    Rotate90FlipX = 5
-    Rotate180FlipX = 6
-    Rotate270FlipX = 7
-    RotateNoneFlipY = Rotate180FlipX
-    Rotate90FlipY = Rotate270FlipX
-    Rotate180FlipY = RotateNoneFlipX
-    Rotate270FlipY = Rotate90FlipX
-    RotateNoneFlipXY = Rotate180FlipNone
-    Rotate90FlipXY = Rotate270FlipNone
-    Rotate180FlipXY = RotateNoneFlipNone
-    Rotate270FlipXY = Rotate90FlipNone
-
-
-class RawFormat:
-    Undefined = 0
-    MemoryBMP = 1
-    BMP = 2
-    EMF = 3
-    WMF = 4
-    JPEG = 5
-    PNG = 6
-    GIF = 7     # MultiFrameBitmap
-    TIFF = 8    # MultiFrameBitmap
-    EXIF = 9
-    Icon = 10
-
-
-class Bitmap:
-    """
-    A simple Bitmap class wraps Windows GDI+ Gdiplus::Bitmap, but may not have high efficiency.
-    The color format is Gdiplus::PixelFormat32bppARGB 0xAARRGGBB, byte order is B G R A.
-    """
-
-    def __init__(self, width: int = 0, height: int = 0):
-        """
-        Create a black transparent(ARGB=0x00000000) bimap of size(width, height).
-        """
-        self._width = width
-        self._height = height
-        self._bitmap = 0
-        self._format = RawFormat.Undefined
-        self._formatStr = ''
-        if width > 0 and height > 0:
-            self._bitmap = _DllClient.instance().dll.BitmapCreate(width, height)
-
-    def __del__(self):
-        self.Close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exceptionType, exceptionValue, exceptionTraceback):
-        self.Close()
-
-    def __bool__(self):
-        return self._bitmap > 0
-
-    def _GetSize(self) -> None:
-        size = _DllClient.instance().dll.BitmapGetWidthAndHeight(ctypes.c_size_t(self._bitmap))
-        self._width = size & 0xFFFFFFFF
-        self._height = size >> 32
-
-    def Close(self) -> None:
-        """Close the underlying Gdiplus::Bitmap object."""
-        if self._bitmap:
-            _DllClient.instance().dll.BitmapRelease(ctypes.c_size_t(self._bitmap))
-            self._bitmap = 0
-            self._width = 0
-            self._height = 0
-
-    Release = Close
-
-    @property
-    def Width(self) -> int:
-        """
-        Property Width.
-        Return int.
-        """
-        return self._width
-
-    @property
-    def Height(self) -> int:
-        """
-        Property Height.
-        Return int.
-        """
-        return self._height
-
-    @staticmethod
-    def FromHandle(handle: int, left: int, top: int, right: int, bottom: int,
-                   captureCursor: bool = False) -> Optional['MemoryBMP']:
-        """
-        Create a `Bitmap` from a native window handle.
-        handle: int, the handle of a native window.
-        left: int.
-        top: int.
-        right: int.
-        bottom: int.
-        left, top, right and bottom are control's internal postion(from 0,0).
-        Return `Bitmap` or None.
-        """
-        rect = None
-        toplevelHandle = GetAncestor(handle, GAFlag.Root)
-        if toplevelHandle and toplevelHandle == handle:
-            if DwmIsCompositionEnabled():
-                rect = DwmGetWindowExtendFrameBounds(handle)
-        if rect is None:
-            rect = GetWindowRect(handle)
-        if rect is None:
-            return None
-        root = GetRootControl()
-        left, top, right, bottom = left + rect.left, top + rect.top, right + rect.left, bottom + rect.top
-        cbmp = _DllClient.instance().dll.BitmapFromWindow(ctypes.c_size_t(root.NativeWindowHandle),
-                                                          left, top, right, bottom,
-                                                          0, 0, int(captureCursor))
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    @staticmethod
-    def FromControl(control: 'Control', x: int = 0, y: int = 0, width: int = 0, height: int = 0,
-                    captureCursor: bool = False) -> Optional['MemoryBMP']:
-        """
-        Create a `Bitmap` from a `Control`.
-        control: `Control` or its subclass.
-        x: int.
-        y: int.
-        width: int.
-        height: int.
-        x, y: the point in control's internal position(from 0,0)
-        width, height: image's width and height from x, y, use 0 for entire area,
-        If width(or height) < 0, image size will be control's width(or height) - width(or height).
-        Return `Bitmap` or None.
-        """
-        rect = control.BoundingRectangle
-        while rect.width() == 0 or rect.height() == 0:
-            # some controls maybe visible but their BoundingRectangle are all 0, capture its parent until valid
-            control = control.GetParentControl()
-            if not control:
-                return None
-            rect = control.BoundingRectangle
-        handle = control.NativeWindowHandle
-        if handle:
-            toplevelHandle = GetAncestor(handle, GAFlag.Root)
-            if toplevelHandle and toplevelHandle == handle:
-                if DwmIsCompositionEnabled():
-                    rect = DwmGetWindowExtendFrameBounds(handle) or rect
-            if width <= 0:
-                width = rect.width() + width
-            if height <= 0:
-                height = rect.height() + height
-            root = GetRootControl()
-            left, top = rect.left + x, rect.top + y
-            right, bottom = left + width, top + height
-            cbmp = _DllClient.instance().dll.BitmapFromWindow(ctypes.c_size_t(root.NativeWindowHandle),
-                                                              left, top, right, bottom,
-                                                              0, 0, int(captureCursor))
-            return Bitmap._FromGdiplusBitmap(cbmp)
-        if width <= 0:
-            width = rect.width() + width
-        if height <= 0:
-            height = rect.height() + height
-        while True:
-            control = control.GetParentControl()
-            handle = control.NativeWindowHandle
-            if handle:
-                pRect = control.BoundingRectangle
-                toplevelHandle = GetAncestor(handle, GAFlag.Root)
-                if toplevelHandle and toplevelHandle == handle:
-                    if DwmIsCompositionEnabled():
-                        pRect = DwmGetWindowExtendFrameBounds(handle) or pRect
-                left = rect.left - pRect.left + x
-                top = rect.top - pRect.top + y
-                right = left + width
-                bottom = top + height
-                break
-        return Bitmap.FromHandle(handle, left, top, right, bottom, captureCursor)
-
-    @staticmethod
-    def _FromGdiplusBitmap(cbmp: int) -> 'Bitmap':
-        """
-        Return `Bitmap`'s subclass instance or None.
-        """
-        if not cbmp:
-            return None
-        formatType = ctypes.c_uint()
-        _DllClient.instance().dll.BitmapGetRawFormat(ctypes.c_size_t(cbmp), ctypes.byref(formatType))
-        if formatType.value == RawFormat.JPEG:
-            bitmap = JPEG()
-        elif formatType.value == RawFormat.PNG:
-            bitmap = PNG()
-        elif formatType.value == RawFormat.GIF:
-            bitmap = GIF()
-            bitmap._bitmap = cbmp
-            bitmap._frameCount = _DllClient.instance().dll.MultiBitmapGetFrameCount(ctypes.c_size_t(cbmp))
-            bitmap._GetGifDealy()
-        elif formatType.value == RawFormat.TIFF:
-            bitmap = TIFF()
-            bitmap._frameCount = _DllClient.instance().dll.MultiBitmapGetFrameCount(ctypes.c_size_t(cbmp))
-        elif formatType.value == RawFormat.BMP:
-            bitmap = BMP()
-        elif formatType.value == RawFormat.MemoryBMP:
-            bitmap = MemoryBMP()
-        elif formatType.value == RawFormat.Icon:
-            bitmap = ICON()
-        elif formatType.value == RawFormat.EMF:
-            bitmap = EMF()
-        elif formatType.value == RawFormat.WMF:
-            bitmap = WMF()
-        elif formatType.value == RawFormat.EXIF:
-            bitmap = EXIF()
-        else:
-            bitmap = Bitmap()
-        bitmap._bitmap = cbmp
-        bitmap._format = formatType.value
-        bitmap._GetSize()
-        return bitmap
-
-    @staticmethod
-    def FromBytes(data: Union[bytes, bytearray], format: str = None, width: int = None, height: int = None) -> Optional['Bitmap']:
-        """
-        Create a `Bitmap` instance from raw BGRA pixel data or image file byte content.
-        data: bytes or bytearray.
-        format (str, optional): Specifies the format of the input data.
-                - Use 'BGRA' for raw pixel data, byte order is B G R A.
-                - Use None for standard image file data (e.g., PNG, JPEG).
-        width (int, optional): The width of the image. Required only when `format` is 'BGRA'.
-        height (int, optional): The height of the image. Required only when `format` is 'BGRA'.
-        Return `Bitmap`'s subclass instance or None.
-        """
-        if format is not None:
-            assert format == 'bgra' or format == 'BGRA'
-            assert len(data) == width * height * 4
-            if isinstance(data, bytearray):
-                pixelBytes = data
-            else:
-                pixelBytes = bytearray(data)
-            pixelArrayType = (ctypes.c_uint32 * (len(pixelBytes) // 4))
-            pixelArray = pixelArrayType.from_buffer(pixelBytes)
-            bitmap = Bitmap(width, height)
-            bitmap.SetAllPixelColors(pixelArray)
-            return bitmap
-        cbmp = _DllClient.instance().dll.BitmapFromBytes(ctypes.c_char_p(data), len(data), 0)
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    @staticmethod
-    def FromFile(filePath: str) -> Optional['Bitmap']:
-        """
-        Create a `Bitmap` from a file path.
-        filePath: str.
-        Return `Bitmap`'s subclass instance or None.
-        """
-        cbmp = _DllClient.instance().dll.BitmapFromFile(ctypes.c_wchar_p(filePath))
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    @staticmethod
-    def FromNDArray(image: 'numpy.ndarray') -> 'MemoryBMP':
-        """
-        Create a `MemoryBMP` from a numpy.ndarray(BGR or BGRA).
-        """
-        import numpy as np
-        assert len(image.shape) == 3 and (image.shape[2] == 3 or image.shape[2] == 4)
-        height, width = image.shape[:2]
-        if image.shape[2] == 3:
-            bgraArray = np.zeros((height, width, 4), dtype=np.uint8)
-            bgraArray[:, :, :3] = image[:, :, :]
-            bgraArray[:, :, 3] = 0xFF
-        else: # 4
-            bgraArray = image
-        pixelBytes = bytearray(bgraArray.tobytes())
-        pixelArrayType = (ctypes.c_uint32 * (len(pixelBytes) // 4))
-        pixelArray = pixelArrayType.from_buffer(pixelBytes)
-        bitmap = MemoryBMP(width, height)
-        bitmap.SetAllPixelColors(pixelArray)
-        return bitmap
-
-    @staticmethod
-    def FromPILImage(image: 'PIL.Image.Image') -> 'MemoryBMP':
-        """
-        Create a `MemoryBMP` from a PIL Image.
-        """
-        assert image.mode == 'RGB' or image.mode == 'RGBA'
-        try:
-            import numpy as np
-            imgArray = np.array(image)
-            if image.mode == 'RGB':
-                imgArray = imgArray[:, :, ::-1]
-            else: # 'RGBA'
-                imgArray = imgArray[:, :, [2, 1, 0, 3]]
-            return Bitmap.FromNDArray(imgArray)
-        except:
-            if image.mode == 'RGB':
-                rgbaImg = image.convert('RGBA')
-                rgbaBytes = rgbaImg.tobytes()
-            else: # 'RGBA'
-                rgbaBytes = image.tobytes()
-            pixelBytes = bytearray(rgbaBytes)
-            for i in range(0, len(pixelBytes), 4):
-                pixel = pixelBytes[i:i+4]
-                pixelBytes[i:i+4] = pixel[2], pixel[1], pixel[0], pixel[3]
-            pixelArrayType = (ctypes.c_uint32 * (len(pixelBytes) // 4))
-            pixelArray = pixelArrayType.from_buffer(pixelBytes)
-            bitmap = MemoryBMP(image.width, image.height)
-            bitmap.SetAllPixelColors(pixelArray)
-            return bitmap
-
-    def ToFile(self, savePath: str, *, quality: int = None) -> bool:
-        """
-        Save to a file.
-        savePath: str, should end with .bmp, .jpg, .jpeg, .png, .gif, .tif, .tiff.
-        quality: int, 1-100, only used when save to jpeg.
-        Return bool, True if succeed otherwise False.
-        Note: If file extension is .gif or .tiff, it is only saved as a single frame.
-              If you want to save a gif or a tiff file with multiple frames, use `GIF.ToGifFile` or `TIFF.ToTiffFile`.
-        """
-        name, ext = os.path.splitext(savePath)
-        extMap = {'.bmp': 'image/bmp',
-                  '.jpg': 'image/jpeg',
-                  '.jpeg': 'image/jpeg',
-                  '.gif': 'image/gif',
-                  '.tif': 'image/tiff',
-                  '.tiff': 'image/tiff',
-                  '.png': 'image/png',
-                  }
-        gdiplusImageFormat = extMap.get(ext.lower(), 'image/png')
-        gdiStatus = _DllClient.instance().dll.BitmapToFile(ctypes.c_size_t(self._bitmap), ctypes.c_wchar_p(savePath), ctypes.c_wchar_p(gdiplusImageFormat), quality or 80)
-        return gdiStatus == 0
-
-    def ToBytes(self, format: str, *, quality: int = None) -> bytearray:
-        """
-        Convert to a bytearray in the specified format.
-        format: str, The desired output format. Supported formats include:
-            - 'BGRA': Raw pixel data without any file header, byte order is B G R A.
-            - 'bmp', 'jpg', 'jpeg', 'gif', 'tif', 'tiff', 'png':
-              Standard image file formats with corresponding file headers.
-        quality: int, 1-100, only used when format is jpg and jpeg.
-        Note: If format is gif or tiff, only the active single frame is saved to a bytearray.
-              Currently multiple frames are not supported.
-        """
-        format = format.lower()
-        if format == 'bgra':
-            return bytearray(memoryview(self.GetAllPixelColors()))
-
-        if format[0] != '.':
-            format = '.' + format
-        extMap = {'.bmp': 'image/bmp',
-                  '.jpg': 'image/jpeg',
-                  '.jpeg': 'image/jpeg',
-                  '.gif': 'image/gif',
-                  '.tif': 'image/tiff',
-                  '.tiff': 'image/tiff',
-                  '.png': 'image/png',
-                  }
-        gdiplusImageFormat = extMap.get(format.lower(), 'image/png')
-        stream = ctypes.c_size_t()
-        gdiStatus = _DllClient.instance().dll.BitmapToStream(
-            ctypes.c_size_t(self._bitmap), ctypes.byref(stream), ctypes.c_wchar_p(gdiplusImageFormat), quality or 80)
-        if stream.value == 0:
-            return None
-        streamSize = _DllClient.instance().dll.GetStreamSize(stream)
-        if streamSize == 0:
-            return None
-        data = bytearray(streamSize)
-        cdata = (ctypes.c_ubyte * streamSize).from_buffer(data)
-        streamSize = _DllClient.instance().dll.CopyStreamData(stream, cdata, streamSize)
-        _DllClient.instance().dll.ReleaseStream(stream)
-        return data
-
-    def ToPILImage(self) -> 'PIL.Image.Image':
-        """
-        Convert to a PIL image.
-        usage:
-        image = bitmap.ToPILImage()
-        image.save("pil.png")
-        image.save("pil.png")
-        image.convert('RGB').save('pil.jpg', quality=80, optimize=True)
-        """
-        from PIL import Image
-        return Image.frombytes('RGBA', (self.Width, self.Height), self.ToBytes('BGRA'), 'raw', 'BGRA')
-
-    def ToNDArray(self) -> 'numpy.ndarray':
-        """
-        Convert to a numpy.ndarray(shape=(height,width,4), compatible with OpenCV).
-        usage:
-        bgraImage = bitmap.ToNDArray()
-        bgrImage = cv2.cvtColor(bgraImage, cv2.COLOR_BGRA2BGR)
-        """
-        import numpy as np
-        npArray = np.frombuffer(self.ToBytes('BGRA'), dtype=np.uint8)
-        return npArray.reshape((self.Height, self.Width, 4))
-
-    def GetRawFormat(self) -> int:
-        """
-        return a int value in class `RawFormat`
-        """
-        if self._format == RawFormat.Undefined:
-            formatType = ctypes.c_uint()
-            _DllClient.instance().dll.BitmapGetRawFormat(ctypes.c_size_t(self._bitmap), ctypes.byref(formatType))
-            self._format = formatType.value
-        return self._format
-
-    def GetRawFormatStr(self) -> str:
-        """
-        return the string description of `RawFormat` value
-        """
-        if not self._formatStr:
-            self._formatStr = _GetDictKeyName(RawFormat.__dict__, self.GetRawFormat())
-        return self._formatStr
-
-    def GetPixelColor(self, x: int, y: int) -> int:
-        """
-        Get color value of a pixel.
-        x: int.
-        y: int.
-        Return int, ARGB(0xAARRGGBB) color format.
-        b = argb & 0x0000_00FF
-        g = (argb & 0x0000_FF00) >> 8
-        r = (argb & 0x00FF_0000) >> 16
-        a = (argb & 0xFF00_0000) >> 24
-        """
-        return _DllClient.instance().dll.BitmapGetPixel(ctypes.c_size_t(self._bitmap), x, y)
-
-    def SetPixelColor(self, x: int, y: int, argb: int) -> bool:
-        """
-        Set color value of a pixel.
-        x: int.
-        y: int.
-        argb: int, ARGB(0xAARRGGBB) color format.
-        Return bool, True if succeed otherwise False.
-        """
-        gdiStatus = _DllClient.instance().dll.BitmapSetPixel(ctypes.c_size_t(self._bitmap), x, y, argb)
-        return gdiStatus == 0
-
-    def GetPixelColorsHorizontally(self, x: int, y: int, count: int) -> ctypes.Array:
-        """
-        x: int.
-        y: int.
-        count: int.
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format form point x,y horizontally.
-        """
-        #assert count <= self.Width * (self.Height - y) - x, 'count > max available from x,y'
-        arrayType = ctypes.c_uint32 * count
-        values = arrayType()
-        gdiStatus = _DllClient.instance().dll.BitmapGetPixelsHorizontally(ctypes.c_size_t(self._bitmap), x, y, values, count)
-        return values
-
-    def SetPixelColorsHorizontally(self, x: int, y: int, colors: Sequence[int]) -> bool:
-        """
-        Set pixel colors form x,y horizontally.
-        x: int.
-        y: int.
-        colors: Sequence[int], an iterable list of int color values in ARGB(0xAARRGGBB) color format,
-            use ctypes.Array for better performance, such as `ctypes.c_uint32 * length`.
-        Return bool, True if succeed otherwise False.
-        """
-        count = len(colors)
-        #assert count <= self.Width * (self.Height - y) - x, 'len(colors) > max available from x,y'
-        if not isinstance(colors, ctypes.Array):
-            arrayType = ctypes.c_uint32 * count
-            colors = arrayType(*colors)
-        gdiStatus = _DllClient.instance().dll.BitmapSetPixelsHorizontally(ctypes.c_size_t(self._bitmap), x, y, colors, count)
-        return gdiStatus == 0
-
-    def GetPixelColorsVertically(self, x: int, y: int, count: int) -> ctypes.Array:
-        """
-        x: int.
-        y: int.
-        count: int.
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format form point x,y vertically.
-        """
-        #assert count <= self.Height * (self.Width - x) - y, 'count > max available from x,y'
-        arrayType = ctypes.c_uint32 * count
-        values = arrayType()
-        gdiStatus = _DllClient.instance().dll.BitmapGetPixelsVertically(ctypes.c_size_t(self._bitmap), x, y, values, count)
-        return values
-
-    def SetPixelColorsVertically(self, x: int, y: int, colors: Sequence[int]) -> bool:
-        """
-        Set pixel colors form x,y vertically.
-        x: int.
-        y: int.
-        colors: Sequence[int], an iterable list of int color values in ARGB(0xAARRGGBB) color format,
-            use ctypes.Array for better performance, such as `ctypes.c_uint32 * length`.
-        Return bool, True if succeed otherwise False.
-        """
-        count = len(colors)
-        #assert count <= self.Height * (self.Width - x) - y, 'len(colors) > max available from x,y'
-        if not isinstance(colors, ctypes.Array):
-            arrayType = ctypes.c_uint32 * count
-            colors = arrayType(*colors)
-        gdiStatus = _DllClient.instance().dll.BitmapSetPixelsVertically(ctypes.c_size_t(self._bitmap), x, y, colors, count)
-        return gdiStatus == 0
-
-    def GetPixelColorsOfRow(self, y: int) -> ctypes.Array:
-        """
-        y: int, row index.
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format of y row.
-        """
-        return self.GetPixelColorsOfRect(0, y, self.Width, 1)
-
-    def GetPixelColorsOfColumn(self, x: int) -> ctypes.Array:
-        """
-        x: int, column index.
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format of x column.
-        """
-        return self.GetPixelColorsOfRect(x, 0, 1, self.Height)
-
-    def GetPixelColorsOfRect(self, x: int, y: int, width: int, height: int) -> ctypes.Array:
-        """
-        x: int.
-        y: int.
-        width: int.
-        height: int.
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format of the input rect.
-        """
-        arrayType = ctypes.c_uint32 * (width * height)
-        values = arrayType()
-        gdiStatus = _DllClient.instance().dll.BitmapGetPixelsOfRect(ctypes.c_size_t(self._bitmap), x, y, width, height, values)
-        return values
-
-    def SetPixelColorsOfRect(self, x: int, y: int, width: int, height: int, colors: Sequence[int]) -> bool:
-        """
-        x: int.
-        y: int.
-        width: int.
-        height: int.
-        colors: Sequence[int], a sequence of int values in ARGB(0xAARRGGBB) color format, it's length must equal to width*height,
-            use ctypes.Array for better performance, such as `ctypes.c_uint32 * (width*height)`.
-        Return bool.
-        """
-        #assert len(colors) == width * height, 'len(colors) != width * height'
-        if not isinstance(colors, ctypes.Array):
-            arrayType = ctypes.c_uint32 * (width * height)
-            colors = arrayType(*colors)
-        gdiStatus = _DllClient.instance().dll.BitmapSetPixelsOfRect(ctypes.c_size_t(self._bitmap), x, y, width, height, colors)
-        return gdiStatus == 0
-
-    def GetPixelColorsOfRects(self, rects: List[Tuple[int, int, int, int]]) -> List[ctypes.Array]:
-        """
-        rects: List[Tuple[int, int, int, int]], such as [(0,0,10,10), (10,10,20,20), (x,y,width,height)].
-        Return List[ctypes.Array], a list whose elements are ctypes.Array which is an iterable array of
-               int values in ARGB(0xAARRGGBB) color format.
-        """
-        return [self.GetPixelColorsOfRect(x, y, width, height) for x, y, width, height in rects]
-
-    def GetAllPixelColors(self) -> ctypes.Array:
-        """
-        Return `ctypes.Array`, an iterable array of int values in ARGB(0xAARRGGBB) color format.
-        """
-        return self.GetPixelColorsOfRect(0, 0, self.Width, self.Height)
-
-    def SetAllPixelColors(self, colors: Sequence[int]) -> bool:
-        """
-        colors: Sequence[int], a sequence of int values in ARGB(0xAARRGGBB) color format, it's length must equal to width*height,
-            use ctypes.Array for better performance, such as `ctypes.c_uint32 * (width*height)`.
-        Return bool.
-        """
-        return self.SetPixelColorsOfRect(0, 0, self.Width, self.Height, colors)
-
-    def Clear(self, color: int = 0xFFFFFFFF, x: int = 0, y: int = 0, width: int = 0, height: int = 0) -> bool:
-        """
-        Set the color of rect(x,y,width,height).
-        color: int, ARGB(0xAARRGGBB) color format.
-        x: int.
-        y: int.
-        width: int, if == 0, the width will be self.Width-x
-        height: int, if == 0, the height will be self.Height-y
-        Return bool.
-        """
-        if width == 0:
-            width = self.Width - x
-        if height == 0:
-            height = self.Height - y
-        arrayType = ctypes.c_uint * (width * height)
-        nativeArray = arrayType(*[color]*(width * height))
-        return self.SetPixelColorsOfRect(x, y, width, height, nativeArray)
-
-    def Clone(self) -> 'MemoryBMP':
-        """
-        Return `Bitmap`'s subclass instance.
-        The cloned Bitmap's RawFormat is same as original Bitmap.
-        If Bitmap is multiple frames, the cloned Bitmap is also multiple frames.
-        """
-        cbmp = _DllClient.instance().dll.BitmapClone(ctypes.c_size_t(self._bitmap), 0, 0, self._width, self._height)
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    def Copy(self, x: int = 0, y: int = 0, width: int = 0, height: int = 0) -> 'MemoryBMP':
-        """
-        x: int, must >= 0.
-        y: int, must >= 0.
-        width: int, must <= self.Width-x.
-        height: int, must <= self.Height-y.
-        Return `MemoryBMP`, a new Bitmap copied from (x,y,width,height).
-        If Bitmap is multiple frames, the cloned Bitmap is only single frame of the active frame.
-        """
-        if width == 0:
-            width = self.Width - x
-        if height == 0:
-            height = self.Height - y
-        nativeArray = self.GetPixelColorsOfRect(x, y, width, height)
-        bitmap = MemoryBMP(width, height)
-        bitmap.SetPixelColorsOfRect(0, 0, width, height, nativeArray)
-        return bitmap
-        # cbmp = _DllClient.instance().dll.BitmapClone(ctypes.c_size_t(self._bitmap), x, y, width, height)
-        # return Bitmap._FromGdiplusBitmap(cbmp)
-
-    def Paste(self, x: int, y: int, bitmap: 'Bitmap') -> bool:
-        """
-        Paste bitmap to (x,y) of self, modify the original Bitmap,
-            if x < 0 or x+bitmap.Width > self.Width, only the intersection part of bitmap is pasted,
-            if y < 0 or y+bitmap.Height > self.Height, only the intersection part of bitmap is pasted.
-        x: int, can < 0.
-        y: int, can < 0.
-        bitmap: `Bitmap`.
-        Return bool, True if bitmap or a part of bitmap is pasted.
-        """
-        left, top, right, bottom = max(0, x), max(0, y), min(self.Width, x + bitmap.Width), min(self.Height, y + bitmap.Height)
-        width, height = right - left, bottom - top
-        if width <= 0 or height <= 0:
-            return False
-        srcX = 0 if x >= 0 else -x
-        srcY = 0 if y >= 0 else -y
-        nativeArray = bitmap.GetPixelColorsOfRect(srcX, srcY, width, height)
-        return self.SetPixelColorsOfRect(left, top, width, height, nativeArray)
-
-    def PastePart(self, dstX: int, dstY: int, srcBitmap: 'Bitmap', srcX: int = 0, srcY: int = 0, srcWidth: int = 0, srcHeight: int = 0) -> bool:
-        """
-        Paste (srcX, srcY, srcWidth, srcHeight) of bitmap to (dstX, dstY) of self, modify the original Bitmap,
-            only the intersection part of the bitmap is pasted.
-        dstX: int, must >= 0.
-        dstY: int, must >= 0.
-        srcBitmap: `Bitmap`.
-        srcX: int, must >= 0.
-        srcY: int, must >= 0.
-        srcWidth: int, must >= 0 and <= srcBitmap.Width - srcX.
-        srcHeight: int, must >= 0 and <= srcBitmap.Height - srcY.
-        Return bool, True if a part of srcBitmap is pasted.
-        """
-        if srcWidth == 0:
-            srcWidth = srcBitmap.Width - srcX
-        if srcHeight == 0:
-            srcHeight = srcBitmap.Height - srcY
-        left, top, right, bottom = max(0, dstX), max(0, dstY), min(self.Width, dstX + srcWidth), min(self.Height, dstY + srcHeight)
-        width, height = right - left, bottom - top
-        if width <= 0 or height <= 0:
-            return False
-        nativeArray = srcBitmap.GetPixelColorsOfRect(srcX, srcY, width, height)
-        return self.SetPixelColorsOfRect(dstX, dstY, width, height, nativeArray)
-
-    def Resize(self, width: int, height: int) -> 'MemoryBMP':
-        """
-        Resize a copy of the original to size (width, height), the original Bitmap is not modified.
-        width: int.
-        height: int.
-        Return a new `MemoryBMP`, the original is not modified.
-        """
-        cbmp = _DllClient.instance().dll.BitmapResize(ctypes.c_size_t(self._bitmap), width, height)
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    def Rotate(self, angle: float, backgroundColor: int = 0xFFFFFFFF) -> 'MemoryBMP':
-        """
-        Rotate angle degrees clockwise around the center point.
-        Return a copy of the original with angle, the original Bitmap is not modified.
-        angle: float, closewise.
-        backgroundColor: int, ARGB(0xAARRGGBB) color format.
-        Return a new `MemoryBMP`, the new Bitmap size may not be the same as the original.
-        """
-        cbmp = _DllClient.instance().dll.BitmapRotate(ctypes.c_size_t(self._bitmap), ctypes.c_float(angle), backgroundColor)
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    def RotateFlip(self, rotateFlip: int) -> 'MemoryBMP':
-        """
-        Rotate 90*n or Filp a copy of the original, the original Bitmap is not modified.
-        rotateFlip: int, a value in class `RotateFlipType`.
-        Return a new `MemoryBMP`, the original is not modified.
-        """
-        bitmap = self.Copy()
-        gdiStatus = _DllClient.instance().dll.BitmapRotateFlip(ctypes.c_size_t(bitmap._bitmap), rotateFlip)
-        bitmap._GetSize()
-        return bitmap
-
-    def RotateWithSameSize(self, dx: float, dy: float, angle: float, backgroundColor: int = 0xFFFFFFFF) -> 'MemoryBMP':
-        """
-        Rotate angle degrees clockwise around the point (dx, dy) from a copy, the original Bitmap is not modified.
-        angle: float, closewise.
-        backgroundColor: int, ARGB(0xAARRGGBB) color format.
-        Return a new `MemoryBMP`, the original is not modified.
-        """
-        cbmp = _DllClient.instance().dll.BitmapRotateWithSameSize(ctypes.c_size_t(self._bitmap),
-            ctypes.c_float(dx), ctypes.c_float(dy), ctypes.c_float(angle), backgroundColor)
-        return Bitmap._FromGdiplusBitmap(cbmp)
-
-    def __str__(self) -> str:
-        return '{}(Width={}, Height={})'.format(self.__class__.__name__, self._width, self._height)
-
-    def __repr__(self) -> str:
-        return '<{}(Width={}, Height={}) at 0x{:X}>'.format(self.__class__.__name__, self._width, self._height, id(self))
-
-
-class MultiFrameBitmap(Bitmap):
-    def __init__(self, width: int = 0, height: int = 0):
-        super().__init__(width, height)
-        self._frameCount = 0
-        self._index = 0
-
-    def SelectActiveFrame(self, index: int) -> bool:
-        gdiStatus = _DllClient.instance().dll.MultiBitmapSelectActiveFrame(ctypes.c_size_t(self._bitmap), index)
-        return gdiStatus == 0
-
-    def GetFrameCount(self) -> int:
-        return self._frameCount
-
-    def __iter__(self):
-        self._index = 0
-        return self
-
-    def __next__(self) -> Bitmap:
-        if self._index < self._frameCount:
-            self.SelectActiveFrame(self._index)
-            self._GetSize()
-            self._index += 1
-            return self.Copy()
-        else:
-            raise StopIteration
-
-    def __str__(self) -> str:
-        return '{}(Width={}, Height={}, FrameCount={})'.format(self.__class__.__name__, self._width, self._height, self._frameCount)
-
-    def __repr__(self) -> str:
-        return '<{}(Width={}, Height={}, FrameCount={}) at 0x{:X}>'.format(self.__class__.__name__, self._width, self._height, self._frameCount, id(self))
-
-
-class MemoryBMP(Bitmap):
-    pass
-
-
-class BMP(Bitmap):
-    pass
-
-
-class JPEG(Bitmap):
-    pass
-
-
-class PNG(Bitmap):
-    pass
-
-
-class EMF(Bitmap):
-    pass
-
-
-class WMF(Bitmap):
-    pass
-
-
-class ICON(Bitmap):
-    pass
-
-
-class EXIF(Bitmap):
-    pass
-
-
-class TIFF(MultiFrameBitmap):
-    @staticmethod
-    def ToTiffFile(path: str, bitmaps: List['Bitmap']) -> bool:
-        '''
-        Save a list of bitmaps to a multi frame tiff file.
-        path: str, file path.
-        bitmaps: List[Bitmap].
-        '''
-        cbitmaps = (ctypes.c_size_t * len(bitmaps))()
-        for i, bmp in enumerate(bitmaps):
-            cbitmaps[i] = bmp._bitmap
-        gdiStatus = _DllClient.instance().dll.MultiBitmapToFile(cbitmaps, None, len(bitmaps),
-                                                                ctypes.c_wchar_p(path), "image/tiff")
-        return gdiStatus == 0
-
-
-class GIF(MultiFrameBitmap):
-    def __init__(self, width: int = 0, height: int = 0):
-        super().__init__(width, height)
-        self._frameDelay = ()
-
-    def _GetGifDealy(self):
-        if self._bitmap:
-            delayDataSize = _DllClient.instance().dll.MultiBitmapGetFrameDelaySize(ctypes.c_size_t(self._bitmap))
-            delayData = (ctypes.c_byte * delayDataSize)()
-            valueOffset = ctypes.c_int()
-            gdiStatus = _DllClient.instance().dll.MultiBitmapGetFrameDelay(ctypes.c_size_t(self._bitmap), delayData, delayDataSize, ctypes.byref(valueOffset))
-            if gdiStatus == 0:
-                valueOffset = valueOffset.value
-                # the uint of frame delay is 1/100 second
-                self._frameDelay = tuple(10*int.from_bytes(delayData[i:i+4], byteorder='little') for i in range(valueOffset, valueOffset+4*self._frameCount, 4))
-
-    def GetFrameDelay(self, index: int) -> int:
-        '''
-        return frame delay in milliseconds
-        '''
-        return self._frameDelay[index]
-
-    def GetFrameDelays(self) -> List[int]:
-        '''
-        return a list of frame delays in milliseconds
-        '''
-        return list(self._frameDelay)
-
-    @staticmethod
-    def ToGifFile(path: str, bitmaps: List[Bitmap], delays: List[int] = None) -> bool:
-        '''
-        Save a list of bitmaps to a multi frame gif file.
-        path: str, file path.
-        bitmaps: List[Bitmap].
-        delays: List[int], frame delay time in milliseconds.
-        Note: every frame delay must be > 10 ms.
-        '''
-        assert len(bitmaps) == len(delays)
-        blen = len(bitmaps)
-        cbitmaps = (ctypes.c_size_t * blen)()
-        cdelays = (ctypes.c_uint32 * blen)()
-        for i, bmp in enumerate(bitmaps):
-            cbitmaps[i] = bmp._bitmap
-            cdelays[i] = delays[i] // 10
-        gdiStatus = _DllClient.instance().dll.SaveGif(cbitmaps, cdelays, blen, ctypes.c_wchar_p(path))
-        return gdiStatus == 0
-
 
 _ClipboardLock = threading.Lock()
 
@@ -2728,49 +1861,6 @@ def SetClipboardHtml(htmlText: str) -> bool:
     return ret
 
 
-def GetClipboardBitmap() -> Optional[Bitmap]:
-    with _ClipboardLock:
-        if _OpenClipboard(0):
-            if ctypes.windll.user32.IsClipboardFormatAvailable(ClipboardFormat.CF_BITMAP):
-                hClipboardData = ctypes.windll.user32.GetClipboardData(ClipboardFormat.CF_BITMAP)
-                cbmp = _DllClient.instance().dll.BitmapFromHBITMAP(ctypes.c_size_t(hClipboardData), 0, 0, 0, 0)
-                bitmap = Bitmap._FromGdiplusBitmap(cbmp)
-                ctypes.windll.user32.CloseClipboard()
-                return bitmap
-    return None
-
-
-def SetClipboardBitmap(bitmap: Bitmap) -> bool:
-    """
-    Return bool, True if succeed otherwise False.
-    """
-    ret = False
-    with _ClipboardLock:
-        if bitmap._bitmap and _OpenClipboard(0):
-            ctypes.windll.user32.EmptyClipboard()
-            hBitmap = _DllClient.instance().dll.BitmapToHBITMAP(ctypes.c_size_t(bitmap._bitmap), 0xFFFFFFFF)
-            hBitmap2 = ctypes.windll.gdi32.CreateBitmap(bitmap.Width, bitmap.Height, 1, 32, 0)
-            hdc = ctypes.windll.user32.GetDC(0)
-            hdc1 = ctypes.windll.gdi32.CreateCompatibleDC(ctypes.c_void_p(hdc))
-            hdc2 = ctypes.windll.gdi32.CreateCompatibleDC(ctypes.c_void_p(hdc))
-            ctypes.windll.user32.ReleaseDC(0, ctypes.c_void_p(hdc))
-            hOldBmp1 = ctypes.windll.gdi32.SelectObject(ctypes.c_void_p(hdc1), ctypes.c_void_p(hBitmap))
-            hOldBmp2 = ctypes.windll.gdi32.SelectObject(ctypes.c_void_p(hdc2), ctypes.c_void_p(hBitmap2))
-            ctypes.windll.gdi32.BitBlt(ctypes.c_void_p(hdc2), 0, 0, bitmap.Width, bitmap.Height, ctypes.c_void_p(hdc1), 0, 0, 0x00CC0020)  # SRCCOPY
-            ctypes.windll.gdi32.SelectObject(ctypes.c_void_p(hdc1), ctypes.c_void_p(hOldBmp1))
-            ctypes.windll.gdi32.SelectObject(ctypes.c_void_p(hdc2), ctypes.c_void_p(hOldBmp2))
-            ctypes.windll.gdi32.DeleteDC(ctypes.c_void_p(hdc1))
-            ctypes.windll.gdi32.DeleteDC(ctypes.c_void_p(hdc2))
-            ctypes.windll.gdi32.DeleteObject(ctypes.c_void_p(hBitmap))
-            # system owns hClipboardData after calling SetClipboardData,
-            # application can not write to or free the data once ownership has been transferred to the system
-            if ctypes.windll.user32.SetClipboardData(ctypes.c_uint(ClipboardFormat.CF_BITMAP), ctypes.c_void_p(hBitmap2)):
-                ret = True
-            else:
-                ctypes.windll.gdi32.DeleteObject(ctypes.c_void_p(hBitmap2))
-            ctypes.windll.user32.CloseClipboard()
-    return ret
-
 
 def Input(prompt: str, consoleColor: int = ConsoleColor.Default) -> str:
     Logger.Write(prompt, consoleColor, writeToFile=False)