rework the new screen DB stuff:
[lilass.git] / 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__) + 1
48         self.text = text
49     def __str__(self):
50         return self.text
51
52 class Resolution:
53     '''Represents a resolution of a screen'''
54     def __init__(self, width, height):
55         self.width = width
56         self.height = height
57     
58     @classmethod
59     def fromDatabase(cls, dbstr):
60         if dbstr is None:
61             return None
62         parts = dbstr.split("x")
63         if len(parts) != 2:
64             raise ValueError(xrandrstr)
65         return Resolution(*map(int,parts))
66     
67     def forDatabase(self):
68         return str(self.width)+'x'+str(self.height)
69     
70     def forXrandr(self):
71         return self.forDatabase()
72     
73     def toTuple(self):
74         return (self.width, self.height)
75     
76     def __eq__(self, other):
77         if not isinstance(other, Resolution):
78             return False
79         return self.width == other.width and self.height == other.height
80     
81     def __ne__(self, other):
82         return not self.__eq__(other)
83     
84     def __hash__(self):
85         return hash(("Resolution",self.width,self.height))
86     
87     def __str__(self):
88         # get ratio
89         ratio = int(round(16.0*self.height/self.width))
90         if ratio == 12: # 16:12 = 4:3
91             strRatio = '4:3'
92         elif ratio == 13: # 16:12.8 = 5:4
93             strRatio = '5:4'
94         else: # let's just hope this will never be 14 or more...
95             strRatio = '16:%d' % ratio
96         return '%dx%d (%s)' %(self.width, self.height, strRatio)
97     
98     def __repr__(self):
99         return 'screen.Resolution('+self.forXrandr()+')'
100     
101     def pixelCount(self):
102         return self.width * self.height
103
104
105 class ScreenSetup:
106     '''Represents a screen configuration (relative to some notion of an "internal" and an "external" screen): Which screens are enabled with which resolution, how
107        are they positioned, which is the primary screen.'''
108     def __init__(self, intResolution, extResolution, relPosition = None, extIsPrimary = True):
109         '''The resolutions can be None to disable the screen, instances of Resolution. The last two arguments only matter if both screens are enabled.'''
110         assert intResolution is None or isinstance(intResolution, Resolution)
111         assert extResolution is None or isinstance(extResolution, Resolution)
112         
113         self.intResolution = intResolution
114         self.extResolution = extResolution
115         self.relPosition = relPosition
116         self.extIsPrimary = extIsPrimary or self.intResolution is None # external is always primary if it is the only one
117     
118     def getInternalArgs(self):
119         if self.intResolution is None:
120             return ["--off"]
121         args = ["--mode", self.intResolution.forXrandr()] # set internal screen to desired resolution
122         if not self.extIsPrimary:
123             args.append('--primary')
124         return args
125     
126     def getExternalArgs(self, intName):
127         if self.extResolution is None:
128             return ["--off"]
129         args = ["--mode", self.extResolution.forXrandr()] # set external screen to desired resolution
130         if self.extIsPrimary:
131             args.append('--primary')
132         if self.intResolution is None:
133             return args
134         # set position
135         args += [{
136                 RelativeScreenPosition.LEFT  : '--left-of',
137                 RelativeScreenPosition.RIGHT : '--right-of',
138                 RelativeScreenPosition.ABOVE : '--above',
139                 RelativeScreenPosition.BELOW : '--below',
140                 RelativeScreenPosition.MIRROR: '--same-as',
141             }[self.relPosition], intName]
142         return args
143     
144     def __str__(self):
145         if self.intResolution is None:
146             return "External display only, at "+str(self.extResolution)
147         if self.extResolution is None:
148             return "Internal display only, at "+str(self.intResolution)
149         return "External display %s at %s %s internal display %s at %s" % ("(primary)" if self.extIsPrimary else "", str(self.extResolution), str(self.relPosition), "" if self.extIsPrimary else "(primary)", str(self.intResolution))
150
151 class Connector:
152     def __init__(self, name=None):
153         self.name = name # connector name, e.g. "HDMI1"
154         self.edid = None # EDID string for the connector, or None if disconnected
155         self._resolutions = set() # set of Resolution objects, empty if disconnected
156         self._preferredResolution = None
157         self.previousResolution = None
158         self.hasLastResolution = False
159     
160     def __str__(self):
161         return str(self.name)
162     
163     def __repr__(self):
164         return """<Connector "%s" EDID="%s" resolutions="%s">""" % (str(self.name), str(self.edid), ", ".join(str(r) for r in self.getResolutionList()))
165     
166     def isConnected(self):
167         assert (self.edid is None) == (len(self._resolutions)==0), "Resolution-EDID mismatch; #resolutions: {}".format(len(self._resolutions))
168         return self.edid is not None
169     
170     def addResolution(self, resolution):
171         assert isinstance(resolution, Resolution)
172         self._resolutions.add(resolution)
173     
174     def appendToEdid(self, s):
175         if self.edid is None:
176             self.edid = s
177         else:
178             self.edid += s
179     
180     def setPreferredResolution(self, resolution):
181         assert isinstance(resolution, Resolution) and resolution in self._resolutions
182         self._preferredResolution = resolution
183     
184     def getPreferredResolution(self):
185         if self._preferredResolution is not None:
186             return self._preferredResolution
187         return self.getResolutionList()[0] # prefer the largest resolution
188     
189     def getResolutionList(self):
190         return sorted(self._resolutions, key=lambda r: -r.pixelCount())
191
192 class ScreenSituation:
193     connectors = [] # contains all the Connector objects
194     internalConnector = None # the internal Connector object (will be an enabled one)
195     externalConnector = None # the used external Connector object (an enabled one), or None
196     previousSetup = None # None or the ScreenSetup used the last time this external screen was connected
197     
198     '''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'''
199     def __init__(self, internalConnectorNames, externalConnectorNames = None):
200         '''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
201            just choose any remaining connector.'''
202         # which connectors are there?
203         self._getXrandrInformation()
204         # figure out which is the internal connector
205         self.internalConnector = self._findAvailableConnector(internalConnectorNames)
206         if self.internalConnector is None:
207             raise Exception("Could not automatically find internal connector, please use (or fix) ~/.dsl.conf to specify it manually.")
208         print("Detected internal connector:",self.internalConnector)
209         # and the external one
210         if externalConnectorNames is None:
211             externalConnectorNames = map(lambda c: c.name, self.connectors)
212             externalConnectorNames = set(filter(lambda name: name != self.internalConnector.name, externalConnectorNames))
213         self.externalConnector = self._findAvailableConnector(externalConnectorNames)
214         if self.internalConnector == self.externalConnector:
215             raise Exception("Internal and external connector are the same. This must not happen. Please fix ~/.dsl.conf.");
216         print("Detected external connector:",self.externalConnector)
217     
218     # Run xrandr and fill the dict of connector names mapped to lists of available resolutions.
219     def _getXrandrInformation(self):
220         connector = None # current connector
221         readingEdid = False
222         for line in processOutputGen("xrandr", "-q", "--verbose"):
223             if readingEdid:
224                 m = re.match(r'^\s*([0-9a-f]+)\s*$', line)
225                 if m is not None:
226                     connector.appendToEdid(m.group(1))
227                     continue
228                 else:
229                     readingEdid = False
230                     # fallthrough to the rest of the loop for parsing of this line
231             # screen?
232             m = re.search(r'^Screen [0-9]+: ', line)
233             if m is not None: # ignore this line
234                 connector = None
235                 continue
236             # new connector?
237             m = re.search(r'^([\w\-]+) (dis)?connected ', line)
238             if m is not None:
239                 connector = Connector(m.group(1))
240                 assert not any(c.name == connector.name for c in self.connectors)
241                 if not connector.name.startswith("VIRTUAL"):
242                     # skip "VIRTUAL" connectors
243                     self.connectors.append(connector)
244                 continue
245             # new resolution?
246             m = re.search(r'^\s*([\d]+)x([\d]+)', line)
247             if m is not None:
248                 resolution = Resolution(int(m.group(1)), int(m.group(2)))
249                 assert connector is not None
250                 connector.addResolution(resolution)
251                 if re.search(r' [+]preferred\b', line):
252                     connector.setPreferredResolution(resolution)
253                 continue
254             # EDID?
255             m = re.search(r'^\s*EDID:\s*$', line)
256             if m is not None:
257                 readingEdid = True
258                 continue
259             # unknown line
260             # not fatal, e.g. xrandr shows strange stuff when a display is enabled, but not connected; --verbose adds a whole lot of other weird stuff
261     
262     # return the first available connector from those listed in <tryConnectorNames>, skipping disabled connectors
263     def _findAvailableConnector(self, tryConnectorNames):
264         for c in filter(lambda c: c.name in tryConnectorNames and c.isConnected(), self.connectors):
265             return c
266         return None
267     
268     # return resolutions available for both internal and external screen
269     def commonResolutions(self):
270         assert self.externalConnector is not None, "Common resolutions may only be queried if there is an external screen connected."
271         internalRes = self.internalConnector.getResolutionList()
272         externalRes = self.externalConnector.getResolutionList()
273         return sorted(set(externalRes).intersection(internalRes), key=lambda r: -r.pixelCount())
274     
275     # compute the xrandr call
276     def forXrandr(self, setup):
277         # turn all screens off
278         connectorArgs = {} # maps connector names to xrand arguments
279         for c in self.connectors:
280             connectorArgs[c.name] = ["--off"]
281         # set arguments for the relevant ones
282         connectorArgs[self.internalConnector.name] = setup.getInternalArgs()
283         if self.externalConnector is not None:
284             connectorArgs[self.externalConnector.name] = setup.getExternalArgs(self.internalConnector.name)
285         else:
286             assert setup.extResolution is None, "There's no external screen to set a resolution for"
287         # now compose the arguments
288         call = ["xrandr"]
289         for name in connectorArgs:
290             call += ["--output", name] + connectorArgs[name]
291         return call
292
293     def fetchDBInfo(self, db):
294         if self.externalConnector and self.externalConnector.edid:
295             self.previousSetup = db.getConfig(self.externalConnector.edid) # may also return None
296         else:
297             self.previousSetup = None
298         if self.previousSetup:
299             print("Known screen, previous setup:", self.previousSetup)
300             self.externalConnector.previousResolution = self.previousSetup.extResolution
301             self.internalConnector.previousResolution = self.previousSetup.intResolution
302     
303     def putDBInfo(self, db, setup):
304         if not self.externalConnector or not self.externalConnector.edid:
305             return
306         db.putConfig(self.externalConnector.edid, setup)