Mac: Better AiO monitor handling

Mickaël Schoentgen · BoboTiG · commit bc5095e8b3e1 · 2017-08-05T13:14:44.000+02:00
diff --git a/.travis.yml b/.travis.yml
@@ -17,7 +17,7 @@ before_install:
   - xpra --xvfb="Xorg +extension RANDR -config `pwd`/tests/res/dummy.xorg.conf -logfile ${HOME}/.xpra/xorg.log" start :42
 
 install:
-  - pip install flake8 numpy pylint
+  - pip install flake8 numpy pillow pylint
   - python setup.py install
 
 script:
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -1,3 +1,11 @@
+3.1.0 (2017-xx-xx)
+==================
+
+darwin.py
+---------
+- Removed `get_infinity()` function
+
+
 3.0.0 (2017-07-06)
 ==================
 
diff --git a/mss/darwin.py b/mss/darwin.py
@@ -26,30 +26,35 @@ def cgfloat():
     return ctypes.c_double if sys.maxsize > 2 ** 32 else ctypes.c_float
 
 
-def get_infinity(maxi=False):
-    # type: (bool) -> float
-    """ Get infinity "numbers". """
-
-    return 1.7976931348623157e+308 if maxi else -8.988465674311579e+307
-
-
 class CGPoint(ctypes.Structure):
     """ Structure that contains coordinates of a rectangle. """
 
     _fields_ = [('x', cgfloat()), ('y', cgfloat())]
 
+    def __repr__(self):
+        return '{0}(left={cls.x} top={cls.y})'.format(
+            type(self).__name__, cls=self)
+
 
 class CGSize(ctypes.Structure):
     """ Structure that contains dimensions of an rectangle. """
 
     _fields_ = [('width', cgfloat()), ('height', cgfloat())]
 
+    def __repr__(self):
+        return '{0}(width={cls.width} height={cls.height})'.format(
+            type(self).__name__, cls=self)
+
 
 class CGRect(ctypes.Structure):
     """ Structure that contains informations about a rectangle. """
 
     _fields_ = [('origin', CGPoint), ('size', CGSize)]
 
+    def __repr__(self):
+        return '{0}<{cls.origin} {cls.size}>'.format(
+            type(self).__name__, cls=self)
+
 
 class MSS(MSSBase):
     """
@@ -81,6 +86,7 @@ def _set_argtypes(self):
             ctypes.POINTER(ctypes.c_uint32)]
         self.core.CGDisplayBounds.argtypes = [ctypes.c_uint32]
         self.core.CGRectStandardize.argtypes = [CGRect]
+        self.core.CGRectUnion.argtypes = [CGRect, CGRect]
         self.core.CGDisplayRotation.argtypes = [ctypes.c_uint32]
         self.core.CGWindowListCreateImage.argtypes = [
             CGRect,
@@ -100,6 +106,7 @@ def _set_restypes(self):
         self.core.CGGetActiveDisplayList.restype = ctypes.c_int32
         self.core.CGDisplayBounds.restype = CGRect
         self.core.CGRectStandardize.restype = CGRect
+        self.core.CGRectUnion.restype = CGRect
         self.core.CGDisplayRotation.restype = ctypes.c_float
         self.core.CGWindowListCreateImage.restype = ctypes.c_void_p
         self.core.CGImageGetDataProvider.restype = ctypes.c_void_p
@@ -115,12 +122,10 @@ def monitors(self):
 
         if not self._monitors:
             # All monitors
-            self._monitors.append({
-                'left': int(get_infinity()),
-                'top': int(get_infinity()),
-                'width': int(get_infinity(True)),
-                'height': int(get_infinity(True)),
-            })
+            # We need to update the value with every single monitor found
+            # using CGRectUnion.  Else we will end with infinite values.
+            all_monitors = CGRect()
+            self._monitors.append({})
 
             # Each monitors
             display_count = ctypes.c_uint32(0)
@@ -133,18 +138,28 @@ def monitors(self):
                 display = active_displays[idx]
                 rect = self.core.CGDisplayBounds(display)
                 rect = self.core.CGRectStandardize(rect)
-                left, top = rect.origin.x, rect.origin.y
                 width, height = rect.size.width, rect.size.height
                 rot = self.core.CGDisplayRotation(display)
                 if rotations[rot] in ['left', 'right']:
                     width, height = height, width
                 self._monitors.append({
-                    'left': int(left),
-                    'top': int(top),
+                    'left': int(rect.origin.x),
+                    'top': int(rect.origin.y),
                     'width': int(width),
                     'height': int(height),
                 })
 
+                # Update AiO monitor's values
+                all_monitors = self.core.CGRectUnion(all_monitors, rect)
+
+            # Update AiO monitor's values
+            self._monitors[0] = {
+                'left': int(all_monitors.origin.x),
+                'top': int(all_monitors.origin.y),
+                'width': int(all_monitors.size.width),
+                'height': int(all_monitors.size.height),
+            }
+
         return self._monitors
 
     def grab(self, monitor):
@@ -178,10 +193,6 @@ def grab(self, monitor):
         if rounded_width != monitor['width']:
             data = self.resize(data, monitor)
 
-        if len(data) != monitor['width'] * monitor['height'] * 4:
-            del data
-            raise ScreenShotError('Data length mismatch.', locals())
-
         return self.cls_image(data, monitor)
 
     @staticmethod
diff --git a/tests/test_implementation.py b/tests/test_implementation.py
@@ -71,6 +71,33 @@ def test_repr(sct):
     assert repr(img) == repr(ref)
 
 
+@pytest.mark.skipif(
+    platform.system().lower() != 'darwin',
+    reason='Specific to macOS.')
+def test_repr():
+    from mss.darwin import CGSize, CGPoint, CGRect
+
+    point = CGPoint(2.0, 1.0)
+    ref = CGPoint()
+    ref.x = 2.0
+    ref.y = 1.0
+    assert repr(point) == repr(ref)
+
+    size = CGSize(2.0, 1.0)
+    ref = CGSize()
+    ref.width = 2.0
+    ref.height = 1.0
+    assert repr(size) == repr(ref)
+
+    rect = CGRect(point, size)
+    ref = CGRect()
+    ref.origin.x = 2.0
+    ref.origin.y = 1.0
+    ref.size.width = 2.0
+    ref.size.height = 1.0
+    assert repr(rect) == repr(ref)
+
+
 @pytest.mark.skipif(
     numpy is None,
     reason='Numpy module not available.')
@@ -113,7 +140,7 @@ def test_factory_basics(monkeypatch):
 
 @pytest.mark.skipif(
     platform.system().lower() != 'linux',
-    reason='To hard to maintain the test for all platforms.')
+    reason='Too hard to maintain the test for all platforms.')
 def test_factory_systems(monkeypatch):
     """ Here, we are testing all systems. """
 
@@ -142,7 +169,7 @@ def test_python_call():
 
 @pytest.mark.skipif(
     platform.system().lower() != 'linux',
-    reason='GNU/Linux test only.')
+    reason='Specific to GNU/Linux.')
 def test_gnu_linux(monkeypatch):
     text = str if sys.version[0] > '2' else unicode
 
@@ -188,3 +215,32 @@ def find_lib(lib):
     import mss.linux
     monkeypatch.setattr(mss.linux, 'Display', lambda: None)
     mss.mss()
+
+
+@pytest.mark.skipif(
+    platform.system().lower() != 'darwin',
+    reason='Specific to macOS.')
+def test_macos(monkeypatch):
+    # No `CoreGraphics` library
+    monkeypatch.setattr(ctypes.util, 'find_library', lambda x: None)
+    with pytest.raises(ScreenShotError):
+        mss.mss()
+    monkeypatch.undo()
+
+    with mss.mss() as sct:
+        # Test monitor's rotation
+        original = sct.monitors[1]
+        monkeypatch.setattr(sct.core, 'CGDisplayRotation',
+                            lambda x: -90.0)
+        sct._monitors = []
+        modified = sct.monitors[1]
+        assert original['width'] == modified['height']
+        assert original['height'] == modified['width']
+        monkeypatch.undo()
+
+        # Test bad data retreival
+        monkeypatch.setattr(sct.core, 'CGWindowListCreateImage',
+                            lambda *args: None)
+        with pytest.raises(ScreenShotError):
+            sct.grab(sct.monitors[1])
+        monkeypatch.undo()
