useful sorting of resolutions

[lilass.git] / screen.py

diff --git a/screen.py b/screen.py
index 78eafa16f939c6ef3630f1c3a793dd13f04a9f5d..f9bef55740804effac631a19b7d00b2b3f290eaa 100644 (file)
--- a/screen.py
+++ b/screen.py
@@ -36,12 +36,16 @@ def processOutputIt(*args):
 
 class RelativeScreenPosition(Enum):
     '''Represents the relative position of the external screen to the internal one'''
 
 class RelativeScreenPosition(Enum):
     '''Represents the relative position of the external screen to the internal one'''

-    LEFT      = 0
-    RIGHT     = 1
-    ABOVE     = 2
-    BELOW     = 3
-    MIRROR    = 4
-
+    LEFT      = ("left of")
+    RIGHT     = ("right of")
+    ABOVE     = ("above")
+    BELOW     = ("below")
+    MIRROR    = ("same as")
+    def __init__(self, text):
+        # auto numbering
+        cls = self.__class__
+        self._value_ = len(cls.__members__)
+        self.text = text

 
 class Resolution:
     '''Represents a resolution of a screen'''
 
 class Resolution:
     '''Represents a resolution of a screen'''


@@ -57,6 +61,9 @@ class Resolution:
     def __ne__(self, other):
         return not self.__eq__(other)
     
     def __ne__(self, other):
         return not self.__eq__(other)
     

+    def __hash__(self):
+        return hash(("Resolution",self.width,self.height))
+    

     def __str__(self):
         # get ratio
         ratio = int(round(16.0*self.height/self.width))
     def __str__(self):
         # get ratio
         ratio = int(round(16.0*self.height/self.width))


@@ -71,6 +78,9 @@ class Resolution:
     def __repr__(self):
         return 'screen.Resolution('+self.forXrandr()+')'
     
     def __repr__(self):
         return 'screen.Resolution('+self.forXrandr()+')'
     

+    def pixelCount(self):
+        return self.width * self.height
+    

     def forXrandr(self):
         return str(self.width)+'x'+str(self.height)
 
     def forXrandr(self):
         return str(self.width)+'x'+str(self.height)
 


@@ -114,11 +124,40 @@ class ScreenSetup:
             }[self.relPosition], intName]
         return args
 
             }[self.relPosition], intName]
         return args
 

+class Connector:
+    def __init__(self, name=None):
+        self.name = name # connector name, e.g. "HDMI1"
+        self.edid = None # EDID string for the connector, or None if disconnected
+        self._resolutions = set() # list of Resolution objects, empty if disconnected
+        self.preferredResolution = None
+    
+    def __str__(self):
+        return str(self.name)
+    
+    def __repr__(self):
+        return """<Connector "%s" EDID="%s" resolutions="%s">""" % (str(self.name), str(self.edid), ", ".join(str(r) for r in self.getResolutionList()))
+    
+    def isConnected(self):
+        assert (self.edid is None) == (len(self._resolutions)==0)
+        return self.edid is not None
+    
+    def addResolution(self, resolution):
+        assert isinstance(resolution, Resolution)
+        self._resolutions.add(resolution)
+    
+    def appendToEdid(self, s):
+        if self.edid is None:
+            self.edid = s
+        else:
+            self.edid += s
+    
+    def getResolutionList(self):
+        return sorted(self._resolutions, key=lambda r: (0 if r==self.preferredResolution else 1, -r.pixelCount()))

 
 class ScreenSituation:
 
 class ScreenSituation:

-    connectors = {} # maps connector names to lists of Resolution (empty list -> disabled connector)
-    internalConnector = None # name of the internal connector (will be an enabled one)
-    externalConnector = None # name of the used external connector (an enabled one), or None
+    connectors = [] # contains all the Connector objects
+    internalConnector = None # the internal Connector object (will be an enabled one)
+    externalConnector = None # the used external Connector object (an enabled one), or None

     
     '''Represents the "screen situation" a machine can be in: Which connectors exist, which resolutions do they have, what are the names for the internal and external screen'''
     def __init__(self, internalConnectorNames, externalConnectorNames = None):
     
     '''Represents the "screen situation" a machine can be in: Which connectors exist, which resolutions do they have, what are the names for the internal and external screen'''
     def __init__(self, internalConnectorNames, externalConnectorNames = None):


@@ -126,6 +165,9 @@ class ScreenSituation:
            just choose any remaining connector.'''
         # which connectors are there?
         self._getXrandrInformation()
            just choose any remaining connector.'''
         # which connectors are there?
         self._getXrandrInformation()

+        for c in self.connectors:
+            print(repr(c))
+            print()

         # figure out which is the internal connector
         self.internalConnector = self._findAvailableConnector(internalConnectorNames)
         if self.internalConnector is None:
         # figure out which is the internal connector
         self.internalConnector = self._findAvailableConnector(internalConnectorNames)
         if self.internalConnector is None:


@@ -133,8 +175,8 @@ class ScreenSituation:
         print("Detected internal connector:",self.internalConnector)
         # and the external one
         if externalConnectorNames is None:
         print("Detected internal connector:",self.internalConnector)
         # and the external one
         if externalConnectorNames is None:

-            externalConnectorNames = list(self.connectors.keys())
-            externalConnectorNames.remove(self.internalConnector)
+            externalConnectorNames = map(lambda c: c.name, self.connectors)
+            externalConnectorNames = set(filter(lambda name: name != self.internalConnector.name, externalConnectorNames))

         self.externalConnector = self._findAvailableConnector(externalConnectorNames)
         if self.internalConnector == self.externalConnector:
             raise Exception("Internal and external connector are the same. This must not happen. Please fix ~/.dsl.conf.");
         self.externalConnector = self._findAvailableConnector(externalConnectorNames)
         if self.internalConnector == self.externalConnector:
             raise Exception("Internal and external connector are the same. This must not happen. Please fix ~/.dsl.conf.");


@@ -143,7 +185,16 @@ class ScreenSituation:
     # Run xrandr and fill the dict of connector names mapped to lists of available resolutions.
     def _getXrandrInformation(self):
         connector = None # current connector
     # Run xrandr and fill the dict of connector names mapped to lists of available resolutions.
     def _getXrandrInformation(self):
         connector = None # current connector

-        for line in processOutputGen("xrandr", "-q"):
+        readingEdid = False
+        for line in processOutputGen("xrandr", "-q", "--verbose"):
+            if readingEdid:
+                m = re.match(r'^\s*([0-9a-f]+)\s*$', line)
+                if m is not None:
+                    connector.appendToEdid(m.group(1))
+                    continue
+                else:
+                    readingEdid = False
+                    # fallthrough to the rest of the loop for parsing of this line

             # screen?
             m = re.search(r'^Screen [0-9]+: ', line)
             if m is not None: # ignore this line
             # screen?
             m = re.search(r'^Screen [0-9]+: ', line)
             if m is not None: # ignore this line


@@ -152,55 +203,61 @@ class ScreenSituation:
             # new connector?
             m = re.search(r'^([\w\-]+) (dis)?connected ', line)
             if m is not None:
             # new connector?
             m = re.search(r'^([\w\-]+) (dis)?connected ', line)
             if m is not None:

-                connector = m.groups()[0]
-                assert connector not in self.connectors
-                self.connectors[connector] = []
+                connector = Connector(m.group(1))
+                assert not any(c.name == connector.name for c in self.connectors)
+                self.connectors.append(connector)

                 continue
             # new resolution?
                 continue
             # new resolution?

-            m = re.search(r'^   ([\d]+)x([\d]+) +', line)
+            m = re.search(r'^\s*([\d]+)x([\d]+)', line)

             if m is not None:
             if m is not None:

-                resolution = Resolution(int(m.groups()[0]), int(m.groups()[1]))
+                resolution = Resolution(int(m.group(1)), int(m.group(2)))

                 assert connector is not None
                 assert connector is not None

-                self.connectors[connector].append(resolution)
+                connector.addResolution(resolution)
+                if '+preferred' in line:
+                    connector.preferredResolution = resolution
+                continue
+            # EDID?
+            m = re.search(r'^\s*EDID:\s*$', line)
+            if m is not None:
+                readingEdid = True

                 continue
             # unknown line
             # not fatal, e.g. xrandr shows strange stuff when a display is enabled, but not connected
                 continue
             # unknown line
             # not fatal, e.g. xrandr shows strange stuff when a display is enabled, but not connected

-            print("Warning: Unknown xrandr line %s" % line)
+            #print("Warning: Unknown xrandr line %s" % line)

     
     

-    # return the first available connector from those listed in <tryConnectors>, skipping disabled connectors
-    def _findAvailableConnector(self, tryConnectors):
-        for connector in tryConnectors:
-            if connector in self.connectors and len(self.connectors[connector]): # if the connector exists and is active (i.e. there is a resolution)
-                return connector
+    # return the first available connector from those listed in <tryConnectorNames>, skipping disabled connectors
+    def _findAvailableConnector(self, tryConnectorNames):
+        for c in filter(lambda c: c.name in tryConnectorNames and c.isConnected(), self.connectors):
+            return c

         return None
     
     # return available internal resolutions
     def internalResolutions(self):
         return None
     
     # return available internal resolutions
     def internalResolutions(self):

-        return self.connectors[self.internalConnector]
+        return self.internalConnector.getResolutionList()

     
     # return available external resolutions (or None, if there is no external screen connected)
     def externalResolutions(self):
         if self.externalConnector is None:
             return None
     
     # return available external resolutions (or None, if there is no external screen connected)
     def externalResolutions(self):
         if self.externalConnector is None:
             return None

-        return self.connectors[self.externalConnector]
+        return self.externalConnector.getResolutionList()

     
     # return resolutions available for both internal and external screen
     def commonResolutions(self):
         internalRes = self.internalResolutions()
         externalRes = self.externalResolutions()
         assert externalRes is not None
     
     # return resolutions available for both internal and external screen
     def commonResolutions(self):
         internalRes = self.internalResolutions()
         externalRes = self.externalResolutions()
         assert externalRes is not None

-        return [res for res in externalRes if res in internalRes]
+        return sorted(set(externalRes).intersection(internalRes), key=lambda r: -r.pixelCount())

     
     # compute the xrandr call
     def forXrandr(self, setup):
         # turn all screens off
         connectorArgs = {} # maps connector names to xrand arguments
     
     # compute the xrandr call
     def forXrandr(self, setup):
         # turn all screens off
         connectorArgs = {} # maps connector names to xrand arguments

-        for c in self.connectors.keys():
-            connectorArgs[c] = ["--off"]
+        for c in self.connectors:
+            connectorArgs[c.name] = ["--off"]

         # set arguments for the relevant ones
         # set arguments for the relevant ones

-        connectorArgs[self.internalConnector] = setup.getInternalArgs()
+        connectorArgs[self.internalConnector.name] = setup.getInternalArgs()

         if self.externalConnector is not None:
         if self.externalConnector is not None:

-            connectorArgs[self.externalConnector] = setup.getExternalArgs(self.internalConnector)
+            connectorArgs[self.externalConnector.name] = setup.getExternalArgs(self.internalConnector.name)

         else:
             assert setup.extResolution is None, "There's no external screen to set a resolution for"
         # now compose the arguments
         else:
             assert setup.extResolution is None, "There's no external screen to set a resolution for"
         # now compose the arguments