#!/usr/bin/env python3 # DSL - easy Display Setup for Laptops # Copyright (C) 2012-2015 Ralf Jung # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. import argparse, sys, os, os.path, shutil, re, subprocess from enum import Enum import gui, screen, util, database frontend = gui.getFrontend("cli") # the fallback, until we got a proper frontend. This is guaranteed to be available. cmdArgs = None # Load a section-less config file: maps parameter names to space-separated lists of strings (with shell quotation) def loadConfigFile(filename): import shlex result = {} if not os.path.exists(filename): return result # no config file # read config file linenr = 0 with open(filename) as f: for line in f: linenr += 1 line = line.strip() if not len(line) or line.startswith("#"): continue # skip empty and comment lines try: # parse line pos = line.index("=") # will raise exception when substring is not found curKey = line[:pos].strip() result[curKey] = shlex.split(line[pos+1:]) # shlex.split also strips except Exception: raise Exception("Invalid config, line %d: Error parsing line (may be a quoting issue)." % linenr) # add some convencience get functions return result # Make sure the backlight is turned on def turnOnBacklight(): try: backlight = float(subprocess.check_output(["xbacklight", "-get"]).strip()) if backlight == 0: # it's completely turned off, we better enable it subprocess.check_call(["xbacklight", "-set", "100"]) except FileNotFoundError: print("xbacklight has not been found, unable to turn your laptop backlight on.") except subprocess.CalledProcessError: print("xbacklight returned an error while attempting to turn your laptop backlight on.") # return the current sceen situation, using the configuration to control connecor detection def situationByConfig(config): # internal connectors if 'internalConnector' in config: if len(config['internalConnector']) != 1: raise Exception("You must specify exactly one internal connector.") internalConnectors = config['internalConnector'] else: internalConnectors = screen.commonInternalConnectorNames() # run! return screen.ScreenSituation(internalConnectors, config.get('externalConnectors')) # if we run top-level if __name__ == "__main__": try: # how do we filter the RelativeScreenPosition for the CLI? relPosFilter = str.lower # parse command-line arguments parser = argparse.ArgumentParser(description='easy Display Setup for Laptops') parser.add_argument("-f", "--frontend", dest="frontend", help="The frontend to be used for user interaction") parser.add_argument("-r", "--relative-position", dest="rel_position", choices=list(map(relPosFilter, screen.RelativeScreenPosition.__members__.keys())), help="Set the position of external screen relative to internal one, in case it is not found in the DB.") parser.add_argument("-e", "--external-only", dest="external_only", action='store_true', help="If an external screen is connected, disable all the others.") parser.add_argument("-i", "--internal-only", dest="internal_only", action='store_true', help="Enable internal screen, disable all the others.") parser.add_argument("-s", "--silent", dest="silent", action='store_true', help="Prefer to be silent: Opens a UI only if the external screen is not known *and* no default configuration (-r/-e/-i) is given.") parser.add_argument("--no-db", dest="use_db", action='store_false', help="Do not use the database of known screens.") parser.add_argument("-v", "--verbose", dest="verbose", action='store_true', help="More verbose output on stderr.") cmdArgs = parser.parse_args() # load frontend early (for error mssages) frontend = gui.getFrontend(cmdArgs.frontend) # find files ## find config file legacyConfigFilePath = os.getenv('HOME') + '/.lilass.conf' configDirectory = util.getConfigDirectory() configFilePath = os.path.join(configDirectory, "lilass.conf") if os.path.isfile(legacyConfigFilePath) and not os.path.isfile(configFilePath): # looks like we just upgraded to a new version of lilass util.mkdirP(configDirectory) shutil.move(legacyConfigFilePath, configFilePath) ## find database dataDirectory = util.getDataDirectory() util.mkdirP(dataDirectory) databaseFilePath = os.path.join(dataDirectory, "collected_data.sqlite") # load configuration config = loadConfigFile(configFilePath) # see what situation we are in situation = situationByConfig(config) # construct the ScreenSetup setup = None if situation.externalConnector is not None: # There's an external screen connected that we may want to use. # Fetch info about this screen from the database. # NOTE: If it is too slow to open the DB twice (reading and saving), we can keep it open all the time if cmdArgs.use_db: with database.Database(databaseFilePath) as db: situation.fetchDBInfo(db) # what to we do? have_default_conf = bool(cmdArgs.external_only or cmdArgs.internal_only or cmdArgs.rel_position) no_ui = bool(have_default_conf or (situation.previousSetup and cmdArgs.silent)) if not no_ui: # ask the user what to do setup = frontend.setup(situation) if setup is None: sys.exit(1) # the user canceled if cmdArgs.use_db: # persists this to disk with database.Database(databaseFilePath) as db: situation.putDBInfo(db, setup) elif situation.previousSetup: # apply the old setup again setup = situation.previousSetup # use default config from CLI elif cmdArgs.external_only: setup = screen.ScreenSetup(intResolution = None, extResolution = situation.externalConnector.getPreferredResolution()) elif cmdArgs.rel_position is not None: # construct automatically, based on CLI arguments # first, figure out the desired RelativeScreenPosition... what a bad hack... relPos = list(filter(lambda relPosItem: relPosFilter(relPosItem[0]) == cmdArgs.rel_position, screen.RelativeScreenPosition.__members__.items())) assert len(relPos) == 1, "CLI argument is ambiguous" relPos = relPos[0][1] # now we construct the ScreenSetup if relPos == screen.RelativeScreenPosition.MIRROR: res = situation.commonResolutions()[0] setup = screen.ScreenSetup(res, res, relPos) else: setup = screen.ScreenSetup(intResolution = situation.internalConnector.getPreferredResolution(), extResolution = situation.externalConnector.getPreferredResolution(), relPosition = relPos) # cmdArgs.internal_only: fall-through if setup is None: assert cmdArgs.internal_only or situation.externalConnector is None # Nothing chosen yet? Use first resolution of internal connector. setup = screen.ScreenSetup(intResolution = situation.internalConnector.getPreferredResolution(), extResolution = None) # call xrandr xrandrCall = situation.forXrandr(setup) print("Call that will be made:",xrandrCall) subprocess.check_call(xrandrCall) # make sure the internal screen is really, *really* turned on if there is no external screen if setup.extResolution is None: turnOnBacklight() except Exception as e: frontend.error(str(e)) if cmdArgs is None or cmdArgs.verbose: raise(e)