dsl.py

   1 #!/usr/bin/python3
   2 # DSL - easy Display Setup for Laptops
   3 # Copyright (C) 2012-2014 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 argparse, sys, os, re, subprocess
  20 from gui import getFrontend
  21 frontend = getFrontend("cli") # the fallback, until we got a proper frontend. This is guaranteed to be available.
  22
  23 # for auto-config: common names of internal connectors
  24 commonInternalConnectorPrefixes = ['LVDS', 'eDP']
  25 commonInternalConnectorSuffices = ['', '0', '1', '-0', '-1']
  26
  27 # this is as close as one can get to an enum in Python
  28 class RelativeScreenPosition:
  29     LEFT          = 0
  30     RIGHT         = 1
  31     EXTERNAL_ONLY = 2
  32     MIRROR        = 3
  33
  34     __names__ = {
  35         'left': LEFT,
  36         'right': RIGHT,
  37         'external-only': EXTERNAL_ONLY,
  38         'mirror': MIRROR
  39     }
  40
  41 # storing what's necessary for screen setup
  42 class ScreenSetup:
  43     def __init__(self, relPosition, intResolution, extResolution, extIsPrimary = False):
  44         '''relPosition must be one of the RelativeScreenPosition members, the resolutions must be (width, height) pairs'''
  45         self.relPosition = relPosition
  46         self.intResolution = intResolution # value doesn't matter if the internal screen is disabled
  47         self.extResolution = extResolution
  48         self.extIsPrimary = extIsPrimary or self.relPosition == RelativeScreenPosition.EXTERNAL_ONLY # external is always primary if it is the only one
  49
  50     def getInternalArgs(self):
  51         if self.relPosition == RelativeScreenPosition.EXTERNAL_ONLY:
  52             return ["--off"]
  53         args = ["--mode", res2xrandr(self.intResolution)] # set internal screen to desired resolution
  54         if not self.extIsPrimary:
  55             args.append('--primary')
  56         return args
  57
  58     def getExternalArgs(self, intName):
  59         args = ["--mode", res2xrandr(self.extResolution)] # set external screen to desired resolution
  60         if self.extIsPrimary:
  61             args.append('--primary')
  62         # set position
  63         if self.relPosition == RelativeScreenPosition.LEFT:
  64             args += ['--left-of', intName]
  65         elif self.relPosition == RelativeScreenPosition.RIGHT:
  66             args += ['--right-of', intName]
  67         elif self.relPosition == RelativeScreenPosition.MIRROR:
  68             args += ['--same-as', intName]
  69         else:
  70             assert self.relPosition == RelativeScreenPosition.EXTERNAL_ONLY
  71         return args
  72
  73 # Load a section-less config file: maps parameter names to space-separated lists of strings (with shell quotation)
  74 def loadConfigFile(filename):
  75     import shlex
  76     result = {}
  77     if not os.path.exists(filename):
  78         return result # no config file
  79     # read config file
  80     linenr = 0
  81     with open(filename) as f:
  82         for line in f:
  83             linenr += 1
  84             line = line.strip()
  85             if not len(line) or line.startswith("#"): continue # skip empty and comment lines
  86             try:
  87                 # parse line
  88                 pos = line.index("=") # will raise exception when substring is not found
  89                 curKey = line[:pos].strip()
  90                 result[curKey] = shlex.split(line[pos+1:]) # shlex.split also strips
  91             except Exception:
  92                 raise Exception("Invalid config, line %d: Error parsing line (may be a quoting issue)." % linenr)
  93     # add some convencience get functions
  94     return result
  95
  96 # iterator yielding common names of internal connectors
  97 def commonInternalConnectorNames():
  98     for prefix in commonInternalConnectorPrefixes:
  99         for suffix in commonInternalConnectorSuffices:
 100             yield prefix+suffix
 101
 102 # helper function: execute a process, return output as iterator, throw exception if there was an error
 103 # you *must* iterate to the end if you use this!
 104 def processOutputGen(*args):
 105     with subprocess.Popen(args, stdout=subprocess.PIPE) as p:
 106         for line in p.stdout:
 107             yield line.decode("utf-8")
 108     if p.returncode != 0:
 109         raise Exception("Error executing "+str(args))
 110 def processOutputIt(*args):
 111     return list(processOutputGen(*args)) # list() iterates over the generator
 112
 113 # Run xrandr and return a dict of output names mapped to lists of available resolutions, each being a (width, height) pair.
 114 # An empty list indicates that the connector is disabled.
 115 def getXrandrInformation():
 116     connectors = {} # map of connector names to a list of resolutions
 117     connector = None # current connector
 118     for line in processOutputGen("xrandr", "-q"):
 119         # screen?
 120         m = re.search(r'^Screen [0-9]+: ', line)
 121         if m is not None: # ignore this line
 122             connector = None
 123             continue
 124         # new connector?
 125         m = re.search(r'^([\w\-]+) (dis)?connected ', line)
 126         if m is not None:
 127             connector = m.groups()[0]
 128             assert connector not in connectors
 129             connectors[connector] = []
 130             continue
 131         # new resolution?
 132         m = re.search(r'^   ([\d]+)x([\d]+) +', line)
 133         if m is not None:
 134             assert connector is not None
 135             connectors[connector].append((int(m.groups()[0]), int(m.groups()[1])))
 136             continue
 137         # unknown line
 138         # not fatal as my xrandr shows strange stuff when a display is enabled, but not connected
 139         #raise Exception("Unknown line in xrandr output:\n"+line)
 140         print("Warning: Unknown xrandr line %s" % line)
 141     return connectors
 142
 143 # convert a (width, height) pair into a string accepted by xrandr as argument for --mode
 144 def res2xrandr(res):
 145     (w, h) = res
 146     return str(w)+'x'+str(h)
 147
 148 # convert a (width, height) pair into a string to be displayed to the user
 149 def res2user(res):
 150     (w, h) = res
 151     # get ratio
 152     ratio = int(round(16.0*h/w))
 153     if ratio == 12: # 16:12 = 4:3
 154         strRatio = '4:3'
 155     elif ratio == 13: # 16:12.8 = 5:4
 156         strRatio = '5:4'
 157     else: # let's just hope this will never be 14 or more...
 158         strRatio = '16:%d' % ratio
 159     return '%dx%d (%s)' %(w, h, strRatio)
 160
 161 # return the first available connector from those listed in tryConnectors, skipping disabled connectors
 162 def findAvailableConnector(tryConnectors, allConnectors):
 163     for connector in tryConnectors:
 164         if connector in allConnectors and allConnectors[connector]: # if the connector exists and is active (i.e. there is a resolution)
 165             return connector
 166     return None
 167
 168 # Return a (internalConnector, externalConnectors) pair: The name of the internal connector, and a list of external connectors.
 169 # Use the config file at ~/.dsl.conf and fall back to auto-detection
 170 def classifyConnectors(allConnectors):
 171     config = loadConfigFile(os.getenv('HOME') + '/.dsl.conf')
 172     # find internal connector
 173     if 'internalConnector' in config:
 174         if len(config['internalConnector']) != 1:
 175             raise Exception("You must specify exactly one internal connector.")
 176         internalConnector = config['internalConnector'][0]
 177         if not internalConnector in allConnectors:
 178             raise Exception("Connector %s does not exist, there is an error in your config file." % internalConnector)
 179     else:
 180         # auto-config
 181         internalConnector = findAvailableConnector(commonInternalConnectorNames(), allConnectors)
 182         if internalConnector is None:
 183             raise Exception("Could not automatically find internal connector, please use ~/.dsl.conf to specify it manually.")
 184     # all the rest is external then, obviously - unless the user wants to do that manually
 185     if 'externalConnectors' in config:
 186         externalConnectors = config['externalConnectors']
 187         for connector in externalConnectors:
 188             if not connector in allConnectors:
 189                 raise Exception("Connector %s does not exist, there is an error in your config file." % connector)
 190             if connector == internalConnector:
 191                 raise Exception("%s is both internal and external, that doesn't make sense." % connector)
 192     else:
 193         externalConnectors = list(allConnectors.keys())
 194         externalConnectors.remove(internalConnector)
 195     if not externalConnectors:
 196         raise Exception("No external connector found - either your config is wrong, or your machine has only one connector.")
 197     # done!
 198     return (internalConnector, externalConnectors)
 199
 200 # if we run top-level
 201 if __name__ == "__main__":
 202     # parse command-line arguments
 203     parser = argparse.ArgumentParser(description='easy Display Setup for Laptops')
 204     parser.add_argument("-f", "--frontend",
 205                         dest="frontend",
 206                         help="The frontend to be used for user interaction")
 207     parser.add_argument("-r", "--relative-position",
 208                         dest="rel_position", choices=RelativeScreenPosition.__names__.keys(),
 209                         help="Position of external screen relative to internal one")
 210     parser.add_argument("-i", "--internal-only",
 211                         dest="internal_only", action='store_true',
 212                         help="Enable internal screen, disable all the others (as if no external screen was connected")
 213     cmdArgs = parser.parse_args()
 214
 215     # load frontend
 216     frontend = getFrontend(cmdArgs.frontend)
 217     try:
 218         # load connectors and classify them
 219         connectors = getXrandrInformation()
 220         (internalConnector, externalConnectors) = classifyConnectors(connectors)
 221
 222         # default: screen off
 223         connectorArgs = {} # maps connector names to xrand arguments
 224         for c in externalConnectors+[internalConnector]:
 225             connectorArgs[c] = ["--off"]
 226
 227         # check whether we got an external screen or not
 228         usedExternalConnector = findAvailableConnector(externalConnectors, connectors) # *the* external connector which is actually used
 229         hasExternal = not cmdArgs.internal_only and usedExternalConnector is not None
 230         if hasExternal:
 231             # compute the list of resolutons available on both
 232             commonRes = [res for res in connectors[usedExternalConnector] if res in connectors[internalConnector]]
 233             # there's an external screen connected, we need to get a setup
 234             if cmdArgs.rel_position is not None:
 235                 # use command-line arguments
 236                 relPosition = RelativeScreenPosition.__names__[cmdArgs.rel_position]
 237                 if relPosition == RelativeScreenPosition.MIRROR:
 238                     setup = ScreenSetup(relPosition, commonRes[0], commonRes[0]) # use default resolutions
 239                 else:
 240                     setup = ScreenSetup(relPosition, connectors[internalConnector][0], connectors[usedExternalConnector][0]) # use default resolutions
 241             else:
 242                 # use GUI
 243                 setup = frontend.setup(connectors[internalConnector], connectors[usedExternalConnector], commonRes)
 244             if setup is None: sys.exit(1) # the user canceled
 245             # apply it
 246             connectorArgs[internalConnector] = setup.getInternalArgs()
 247             connectorArgs[usedExternalConnector] = setup.getExternalArgs(internalConnector)
 248         else:
 249             # use first resolution of internal connector
 250             connectorArgs[internalConnector] = ["--mode", res2xrandr(connectors[internalConnector][0]), "--primary"]
 251
 252         # and do it
 253         call = ["xrandr"]
 254         for name in connectorArgs:
 255             call += ["--output", name] + connectorArgs[name]
 256         print("Call that will be made:",call)
 257         subprocess.check_call(call)
 258
 259         # make sure the internal screen is really, *really* turned on if there is no external screen
 260         if not hasExternal:
 261             try:
 262                 backlight = float(subprocess.check_output(["xbacklight", "-get"]).strip())
 263                 if backlight == 0: # it's completely turned off, we better enable it
 264                     subprocess.check_call(["xbacklight", "-set", "100"])
 265             except FileNotFoundError:
 266                 print("xbacklight has not been found, unable to turn your laptop backlight on.")
 267     except Exception as e:
 268         frontend.error(str(e))
 269         raise