screen.py

   1 #!/usr/bin/python3
   2 # DSL - easy Display Setup for Laptops
   3 # Copyright (C) 2012-2015 Ralf Jung <post@ralfj.de>
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18
  19 import re, subprocess
  20 from enum import Enum
  21
  22 ## utility functions
  23
  24 # execute a process, return output as iterator, throw exception if there was an error
  25 # you *must* iterate to the end if you use this!
  26 def processOutputGen(*args):
  27     with subprocess.Popen(args, stdout=subprocess.PIPE) as p:
  28         for line in p.stdout:
  29             yield line.decode("utf-8")
  30     if p.returncode != 0:
  31         raise Exception("Error executing "+str(args))
  32 def processOutputIt(*args):
  33     return list(processOutputGen(*args)) # list() iterates over the generator
  34
  35 ## the classes
  36
  37 class RelativeScreenPosition(Enum):
  38     '''Represents the relative position of the external screen to the internal one'''
  39     LEFT      = ("left of")
  40     RIGHT     = ("right of")
  41     ABOVE     = ("above")
  42     BELOW     = ("below")
  43     MIRROR    = ("same as")
  44     def __init__(self, text):
  45         # auto numbering
  46         cls = self.__class__
  47         self._value_ = len(cls.__members__)
  48         self.text = text
  49
  50 class Resolution:
  51     '''Represents a resolution of a screen'''
  52     def __init__(self, width, height):
  53         self.width = width
  54         self.height = height
  55
  56     def __eq__(self, other):
  57         if not isinstance(other, Resolution):
  58             return False
  59         return self.width == other.width and self.height == other.height
  60
  61     def __ne__(self, other):
  62         return not self.__eq__(other)
  63
  64     def __hash__(self):
  65         return hash(("Resolution",self.width,self.height))
  66
  67     def __str__(self):
  68         # get ratio
  69         ratio = int(round(16.0*self.height/self.width))
  70         if ratio == 12: # 16:12 = 4:3
  71             strRatio = '4:3'
  72         elif ratio == 13: # 16:12.8 = 5:4
  73             strRatio = '5:4'
  74         else: # let's just hope this will never be 14 or more...
  75             strRatio = '16:%d' % ratio
  76         return '%dx%d (%s)' %(self.width, self.height, strRatio)
  77
  78     def __repr__(self):
  79         return 'screen.Resolution('+self.forXrandr()+')'
  80
  81     def pixelCount(self):
  82         return self.width * self.height
  83
  84     def forXrandr(self):
  85         return str(self.width)+'x'+str(self.height)
  86
  87
  88 class ScreenSetup:
  89     '''Represents a screen configuration (relative to some notion of an "internal" and an "external" screen): Which screens are enabled with which resolution, how
  90        are they positioned, which is the primary screen.'''
  91     def __init__(self, intResolution, extResolution, relPosition = None, extIsPrimary = True):
  92         '''The resolutions can be None to disable the screen, instances of Resolution. The last two arguments only matter if both screens are enabled.'''
  93         assert intResolution is None or isinstance(intResolution, Resolution)
  94         assert extResolution is None or isinstance(extResolution, Resolution)
  95
  96         self.intResolution = intResolution
  97         self.extResolution = extResolution
  98         self.relPosition = relPosition
  99         self.extIsPrimary = extIsPrimary or self.intResolution is None # external is always primary if it is the only one
 100
 101     def getInternalArgs(self):
 102         if self.intResolution is None:
 103             return ["--off"]
 104         args = ["--mode", self.intResolution.forXrandr()] # set internal screen to desired resolution
 105         if not self.extIsPrimary:
 106             args.append('--primary')
 107         return args
 108
 109     def getExternalArgs(self, intName):
 110         if self.extResolution is None:
 111             return ["--off"]
 112         args = ["--mode", self.extResolution.forXrandr()] # set external screen to desired resolution
 113         if self.extIsPrimary:
 114             args.append('--primary')
 115         if self.intResolution is None:
 116             return args
 117         # set position
 118         args += [{
 119                 RelativeScreenPosition.LEFT  : '--left-of',
 120                 RelativeScreenPosition.RIGHT : '--right-of',
 121                 RelativeScreenPosition.ABOVE : '--above',
 122                 RelativeScreenPosition.BELOW : '--below',
 123                 RelativeScreenPosition.MIRROR: '--same-as',
 124             }[self.relPosition], intName]
 125         return args
 126
 127 class Connector:
 128     def __init__(self, name=None):
 129         self.name = name # connector name, e.g. "HDMI1"
 130         self.edid = None # EDID string for the connector, or None if disconnected
 131         self._resolutions = set() # list of Resolution objects, empty if disconnected
 132         self.preferredResolution = None
 133
 134     def __str__(self):
 135         return str(self.name)
 136
 137     def __repr__(self):
 138         return """<Connector "%s" EDID="%s" resolutions="%s">""" % (str(self.name), str(self.edid), ", ".join(str(r) for r in self.getResolutionList()))
 139
 140     def isConnected(self):
 141         assert (self.edid is None) == (len(self._resolutions)==0)
 142         return self.edid is not None
 143
 144     def addResolution(self, resolution):
 145         assert isinstance(resolution, Resolution)
 146         self._resolutions.add(resolution)
 147
 148     def appendToEdid(self, s):
 149         if self.edid is None:
 150             self.edid = s
 151         else:
 152             self.edid += s
 153
 154     def getResolutionList(self):
 155         return sorted(self._resolutions, key=lambda r: (0 if r==self.preferredResolution else 1, -r.pixelCount()))
 156
 157 class ScreenSituation:
 158     connectors = [] # contains all the Connector objects
 159     internalConnector = None # the internal Connector object (will be an enabled one)
 160     externalConnector = None # the used external Connector object (an enabled one), or None
 161
 162     '''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'''
 163     def __init__(self, internalConnectorNames, externalConnectorNames = None):
 164         '''Both arguments are lists of connector names. The first one which exists and has a screen attached is chosen for that class. <externalConnectorNames> can be None to
 165            just choose any remaining connector.'''
 166         # which connectors are there?
 167         self._getXrandrInformation()
 168         for c in self.connectors:
 169             print(repr(c))
 170             print()
 171         # figure out which is the internal connector
 172         self.internalConnector = self._findAvailableConnector(internalConnectorNames)
 173         if self.internalConnector is None:
 174             raise Exception("Could not automatically find internal connector, please use (or fix) ~/.dsl.conf to specify it manually.")
 175         print("Detected internal connector:",self.internalConnector)
 176         # and the external one
 177         if externalConnectorNames is None:
 178             externalConnectorNames = map(lambda c: c.name, self.connectors)
 179             externalConnectorNames = set(filter(lambda name: name != self.internalConnector.name, externalConnectorNames))
 180         self.externalConnector = self._findAvailableConnector(externalConnectorNames)
 181         if self.internalConnector == self.externalConnector:
 182             raise Exception("Internal and external connector are the same. This must not happen. Please fix ~/.dsl.conf.");
 183         print("Detected external connector:",self.externalConnector)
 184
 185     # Run xrandr and fill the dict of connector names mapped to lists of available resolutions.
 186     def _getXrandrInformation(self):
 187         connector = None # current connector
 188         readingEdid = False
 189         for line in processOutputGen("xrandr", "-q", "--verbose"):
 190             if readingEdid:
 191                 m = re.match(r'^\s*([0-9a-f]+)\s*$', line)
 192                 if m is not None:
 193                     connector.appendToEdid(m.group(1))
 194                     continue
 195                 else:
 196                     readingEdid = False
 197                     # fallthrough to the rest of the loop for parsing of this line
 198             # screen?
 199             m = re.search(r'^Screen [0-9]+: ', line)
 200             if m is not None: # ignore this line
 201                 connector = None
 202                 continue
 203             # new connector?
 204             m = re.search(r'^([\w\-]+) (dis)?connected ', line)
 205             if m is not None:
 206                 connector = Connector(m.group(1))
 207                 assert not any(c.name == connector.name for c in self.connectors)
 208                 self.connectors.append(connector)
 209                 continue
 210             # new resolution?
 211             m = re.search(r'^\s*([\d]+)x([\d]+)', line)
 212             if m is not None:
 213                 resolution = Resolution(int(m.group(1)), int(m.group(2)))
 214                 assert connector is not None
 215                 connector.addResolution(resolution)
 216                 if '+preferred' in line:
 217                     connector.preferredResolution = resolution
 218                 continue
 219             # EDID?
 220             m = re.search(r'^\s*EDID:\s*$', line)
 221             if m is not None:
 222                 readingEdid = True
 223                 continue
 224             # unknown line
 225             # not fatal, e.g. xrandr shows strange stuff when a display is enabled, but not connected
 226             #print("Warning: Unknown xrandr line %s" % line)
 227
 228     # return the first available connector from those listed in <tryConnectorNames>, skipping disabled connectors
 229     def _findAvailableConnector(self, tryConnectorNames):
 230         for c in filter(lambda c: c.name in tryConnectorNames and c.isConnected(), self.connectors):
 231             return c
 232         return None
 233
 234     # return available internal resolutions
 235     def internalResolutions(self):
 236         return self.internalConnector.getResolutionList()
 237
 238     # return available external resolutions (or None, if there is no external screen connected)
 239     def externalResolutions(self):
 240         if self.externalConnector is None:
 241             return None
 242         return self.externalConnector.getResolutionList()
 243
 244     # return resolutions available for both internal and external screen
 245     def commonResolutions(self):
 246         internalRes = self.internalResolutions()
 247         externalRes = self.externalResolutions()
 248         assert externalRes is not None
 249         return sorted(set(externalRes).intersection(internalRes), key=lambda r: -r.pixelCount())
 250
 251     # compute the xrandr call
 252     def forXrandr(self, setup):
 253         # turn all screens off
 254         connectorArgs = {} # maps connector names to xrand arguments
 255         for c in self.connectors:
 256             connectorArgs[c.name] = ["--off"]
 257         # set arguments for the relevant ones
 258         connectorArgs[self.internalConnector.name] = setup.getInternalArgs()
 259         if self.externalConnector is not None:
 260             connectorArgs[self.externalConnector.name] = setup.getExternalArgs(self.internalConnector.name)
 261         else:
 262             assert setup.extResolution is None, "There's no external screen to set a resolution for"
 263         # now compose the arguments
 264         call = ["xrandr"]
 265         for name in connectorArgs:
 266             call += ["--output", name] + connectorArgs[name]
 267         return call
 268