def __init__(self, text):
# auto numbering
cls = self.__class__
- self._value_ = len(cls.__members__)
+ self._value_ = len(cls.__members__) + 1
self.text = text
-
+ def __str__(self):
+ return self.text
class Resolution:
'''Represents a resolution of a screen'''
self.width = width
self.height = height
+ @classmethod
+ def fromDatabase(cls, dbstr):
+ if dbstr is None:
+ return None
+ parts = dbstr.split("x")
+ if len(parts) != 2:
+ raise ValueError(xrandrstr)
+ return Resolution(*map(int,parts))
+
+ def forDatabase(self):
+ return str(self.width)+'x'+str(self.height)
+
+ def forXrandr(self):
+ return self.forDatabase()
+
+ def toTuple(self):
+ return (self.width, self.height)
+
def __eq__(self, other):
if not isinstance(other, Resolution):
return False
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))
- if ratio == 12: # 16:12 = 4:3
+ if ratio == 11: # 16:10.66 = 3:2
+ strRatio = "3:2"
+ elif ratio == 12: # 16:12 = 4:3
strRatio = '4:3'
elif ratio == 13: # 16:12.8 = 5:4
strRatio = '5:4'
def __repr__(self):
return 'screen.Resolution('+self.forXrandr()+')'
- def forXrandr(self):
- return str(self.width)+'x'+str(self.height)
+ def pixelCount(self):
+ return self.width * self.height
class ScreenSetup:
RelativeScreenPosition.MIRROR: '--same-as',
}[self.relPosition], intName]
return args
+
+ def __str__(self):
+ if self.intResolution is None:
+ return "External display only, at "+str(self.extResolution)
+ if self.extResolution is None:
+ return "Internal display only, at "+str(self.intResolution)
+ 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))
class Connector:
- name = None # connector name, e.g. "HDMI1"
- edid = None # EDID string for the connector, or None if disconnected
- resolutions = [] # list of Resolution objects, empty if disconnected
-
def __init__(self, name=None):
- self.name = name
+ self.name = name # connector name, e.g. "HDMI1"
+ self.edid = None # EDID string for the connector, or None if disconnected
+ self._resolutions = set() # set of Resolution objects, empty if disconnected
+ self._preferredResolution = None
+ self.previousResolution = None
+ self.hasLastResolution = False
+
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)
+ assert (self.edid is None) == (len(self._resolutions)==0), "Resolution-EDID mismatch; #resolutions: {}".format(len(self._resolutions))
return self.edid is not None
+
def addResolution(self, resolution):
assert isinstance(resolution, Resolution)
- self.resolutions.append(resolution)
+ self._resolutions.add(resolution)
+
def appendToEdid(self, s):
if self.edid is None:
self.edid = s
else:
self.edid += s
+
+ def setPreferredResolution(self, resolution):
+ assert isinstance(resolution, Resolution) and resolution in self._resolutions
+ self._preferredResolution = resolution
+
+ def getPreferredResolution(self):
+ if self._preferredResolution is not None:
+ return self._preferredResolution
+ return self.getResolutionList()[0] # prefer the largest resolution
+
+ def getResolutionList(self):
+ return sorted(self._resolutions, key=lambda r: -r.pixelCount())
class ScreenSituation:
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
+ previousSetup = None # None or the ScreenSetup used the last time this external screen was connected
'''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):
# and the external one
if externalConnectorNames is None:
externalConnectorNames = map(lambda c: c.name, self.connectors)
- externalConnectorNames = filter(lambda name: name != self.internalConnector.name, externalConnectorNames)
+ 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.");
if m is not None:
connector = Connector(m.group(1))
assert not any(c.name == connector.name for c in self.connectors)
- self.connectors.append(connector)
+ if not connector.name.startswith("VIRTUAL"):
+ # skip "VIRTUAL" connectors
+ self.connectors.append(connector)
continue
# new resolution?
m = re.search(r'^\s*([\d]+)x([\d]+)', line)
resolution = Resolution(int(m.group(1)), int(m.group(2)))
assert connector is not None
connector.addResolution(resolution)
+ if re.search(r' [+]preferred\b', line):
+ connector.setPreferredResolution(resolution)
continue
# EDID?
m = re.search(r'^\s*EDID:\s*$', line)
readingEdid = True
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)
+ # 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
# return the first available connector from those listed in <tryConnectorNames>, skipping disabled connectors
def _findAvailableConnector(self, tryConnectorNames):
return c
return None
- # return available internal resolutions
- def internalResolutions(self):
- return self.internalConnector.resolutions
-
- # 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.externalConnector.resolutions
-
# 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]
+ assert self.externalConnector is not None, "Common resolutions may only be queried if there is an external screen connected."
+ internalRes = self.internalConnector.getResolutionList()
+ externalRes = self.externalConnector.getResolutionList()
+ return sorted(set(externalRes).intersection(internalRes), key=lambda r: -r.pixelCount())
# compute the xrandr call
def forXrandr(self, setup):
call += ["--output", name] + connectorArgs[name]
return call
+ def fetchDBInfo(self, db):
+ if self.externalConnector and self.externalConnector.edid:
+ self.previousSetup = db.getConfig(self.externalConnector.edid) # may also return None
+ else:
+ self.previousSetup = None
+ if self.previousSetup:
+ print("Known screen, previous setup:", self.previousSetup)
+ self.externalConnector.previousResolution = self.previousSetup.extResolution
+ self.internalConnector.previousResolution = self.previousSetup.intResolution
+
+ def putDBInfo(self, db, setup):
+ if not self.externalConnector or not self.externalConnector.edid:
+ return
+ db.putConfig(self.externalConnector.edid, setup)
projects / lilass.git / blobdiff