MSS: reworked how C functions are initialised

Author: BoboTiG

CHANGELOG

@@ -3,6 +3,7 @@ History:
 <see Git checking messages for history>
 
 6.0.1   2020/xx/xx
+      - MSS: reworked how C functions are initialised
       - Mac: reduce the number of function calls
       - Mac: support macOS Big Sur (fixes #178)
       - tests: fix macOS intepreter not found on Travis-CI

docs/source/api.rst

@@ -5,11 +5,20 @@ MSS API
 Classes
 =======
 
+macOS
+-----
+
+.. module:: mss.darwin
+
+.. attribute:: CFUNCTIONS
+
 GNU/Linux
 ---------
 
 .. module:: mss.linux
 
+.. attribute:: CFUNCTIONS
+
 .. attribute:: ERROR
 
     :type: types.SimpleNamspacedict
@@ -18,6 +27,10 @@ GNU/Linux
 
     .. versionadded:: 5.0.0
 
+.. attribute:: PLAINMASK
+
+.. attribute:: ZPIXMAP
+
 .. class:: MSS
 
     .. method:: __init__([display=None])
@@ -76,6 +89,18 @@ GNU/Linux
 
     .. versionadded:: 3.3.0
 
+Windows
+-------
+
+.. module:: mss.windows
+
+.. attribute:: CAPTUREBLT
+
+.. attribute:: CFUNCTIONS
+
+.. attribute:: DIB_RGB_COLORS
+
+.. attribute:: SRCCOPY
 
 Methods
 =======

mss/darwin.py

@@ -6,6 +6,17 @@
 import ctypes
 import ctypes.util
 import sys
+from ctypes import (
+    POINTER,
+    Structure,
+    c_double,
+    c_float,
+    c_int32,
+    c_uint64,
+    c_ubyte,
+    c_uint32,
+    c_void_p,
+)
 from platform import mac_ver
 from typing import TYPE_CHECKING
 
@@ -23,13 +34,13 @@
 
 
 def cgfloat():
-    # type: () -> Union[Type[ctypes.c_double], Type[ctypes.c_float]]
+    # type: () -> Union[Type[c_double], Type[c_float]]
     """ Get the appropriate value for a float. """
 
-    return ctypes.c_double if sys.maxsize > 2 ** 32 else ctypes.c_float
+    return c_double if sys.maxsize > 2 ** 32 else c_float
 
 
-class CGPoint(ctypes.Structure):
+class CGPoint(Structure):
     """ Structure that contains coordinates of a rectangle. """
 
     _fields_ = [("x", cgfloat()), ("y", cgfloat())]
@@ -38,7 +49,7 @@ def __repr__(self):
         return "{}(left={} top={})".format(type(self).__name__, self.x, self.y)
 
 
-class CGSize(ctypes.Structure):
+class CGSize(Structure):
     """ Structure that contains dimensions of an rectangle. """
 
     _fields_ = [("width", cgfloat()), ("height", cgfloat())]
@@ -49,7 +60,7 @@ def __repr__(self):
         )
 
 
-class CGRect(ctypes.Structure):
+class CGRect(Structure):
     """ Structure that contains information about a rectangle. """
 
     _fields_ = [("origin", CGPoint), ("size", CGSize)]
@@ -58,6 +69,42 @@ def __repr__(self):
         return "{}<{} {}>".format(type(self).__name__, self.origin, self.size)
 
 
+# C functions that will be initialised later.
+#
+# This is a dict:
+#    cfunction: (attr, argtypes, restype)
+#
+# Available attr: core.
+#
+# Note: keep it sorted by cfunction.
+CFUNCTIONS = {
+    "CGDataProviderCopyData": ("core", [c_void_p], c_void_p),
+    "CGDisplayBounds": ("core", [c_uint32], CGRect),
+    "CGDisplayRotation": ("core", [c_uint32], c_float),
+    "CFDataGetBytePtr": ("core", [c_void_p], c_void_p),
+    "CFDataGetLength": ("core", [c_void_p], c_uint64),
+    "CFRelease": ("core", [c_void_p], c_void_p),
+    "CGDataProviderRelease": ("core", [c_void_p], c_void_p),
+    "CGGetActiveDisplayList": (
+        "core",
+        [c_uint32, POINTER(c_uint32), POINTER(c_uint32)],
+        c_int32,
+    ),
+    "CGImageGetBitsPerPixel": ("core", [c_void_p], int),
+    "CGImageGetBytesPerRow": ("core", [c_void_p], int),
+    "CGImageGetDataProvider": ("core", [c_void_p], c_void_p),
+    "CGImageGetHeight": ("core", [c_void_p], int),
+    "CGImageGetWidth": ("core", [c_void_p], int),
+    "CGRectStandardize": ("core", [CGRect], CGRect),
+    "CGRectUnion": ("core", [CGRect, CGRect], CGRect),
+    "CGWindowListCreateImage": (
+        "core",
+        [CGRect, c_uint32, c_uint32, c_uint32],
+        c_void_p,
+    ),
+}
+
+
 class MSS(MSSBase):
     """
     Multiple ScreenShots implementation for macOS.
@@ -94,36 +141,15 @@ def _set_cfunctions(self):
         # type: () -> None
         """ Set all ctypes functions and attach them to attributes. """
 
-        uint32 = ctypes.c_uint32
-        void = ctypes.c_void_p
-        pointer = ctypes.POINTER
         cfactory = self._cfactory
-        core = self.core
-
-        # Note: keep it sorted
-        for func, argtypes, restype in (
-            ("CGDataProviderCopyData", [void], void),
-            ("CGDisplayBounds", [uint32], CGRect),
-            ("CGDisplayRotation", [uint32], ctypes.c_float),
-            ("CFDataGetBytePtr", [void], void),
-            ("CFDataGetLength", [void], ctypes.c_uint64),
-            ("CFRelease", [void], void),
-            ("CGDataProviderRelease", [void], void),
-            (
-                "CGGetActiveDisplayList",
-                [uint32, pointer(uint32), pointer(uint32)],
-                ctypes.c_int32,
-            ),
-            ("CGImageGetBitsPerPixel", [void], int),
-            ("CGImageGetBytesPerRow", [void], int),
-            ("CGImageGetDataProvider", [void], void),
-            ("CGImageGetHeight", [void], int),
-            ("CGImageGetWidth", [void], int),
-            ("CGRectStandardize", [CGRect], CGRect),
-            ("CGRectUnion", [CGRect, CGRect], CGRect),
-            ("CGWindowListCreateImage", [CGRect, uint32, uint32, uint32], void),
-        ):
-            cfactory(attr=core, func=func, argtypes=argtypes, restype=restype)  # type: ignore
+        attrs = {"core": self.core}
+        for func, (attr, argtypes, restype) in CFUNCTIONS.items():
+            cfactory(
+                attr=attrs[attr],
+                func=func,
+                argtypes=argtypes,  # type: ignore
+                restype=restype,
+            )
 
     def _monitors_impl(self):
         # type: () -> None
@@ -139,8 +165,8 @@ def _monitors_impl(self):
         self._monitors.append({})
 
         # Each monitors
-        display_count = ctypes.c_uint32(0)
-        active_displays = (ctypes.c_uint32 * self.max_displays)()
+        display_count = c_uint32(0)
+        active_displays = (c_uint32 * self.max_displays)()
         core.CGGetActiveDisplayList(
             self.max_displays, active_displays, ctypes.byref(display_count)
         )
@@ -196,7 +222,7 @@ def _grab_impl(self, monitor):
             copy_data = core.CGDataProviderCopyData(prov)
             data_ref = core.CFDataGetBytePtr(copy_data)
             buf_len = core.CFDataGetLength(copy_data)
-            raw = ctypes.cast(data_ref, ctypes.POINTER(ctypes.c_ubyte * buf_len))
+            raw = ctypes.cast(data_ref, POINTER(c_ubyte * buf_len))
             data = bytearray(raw.contents)
 
             # Remove padding per row