Search code examples
pythonwindowscross-platformdesktop-applicationscreen-resolution

Resize display resolution using python with cross platform support


Resize display resolution using a python function. It should be cross platform, ie support for windows, linux and mac (it is okay to have multiple cases depending on the operating system)

I have code which I think works on linux (Ubuntu) I am looking for a solution for windows and mac (should support both 32 and 64 bit machines)

def SetResolution(width, height):
    os.popen("xrandr -s "+str(width)+'x'+str(height))

I would also appreciate it if somebody could tell me how I could get the possible display resolutions for windows and mac

my function on linux is this:

def GetResolutions():
    screen = os.popen("xrandr").readlines()
    possibleResolutions = []
    for a in screen:
        data = a.split()
        if len(data)<4:
            width, height = data[0].split('x')
            fps = re.sub("[^0-9.]", "", data[1])
            possibleResolutions.append({'width':int(width),'height':int(height),'fps':float(fps)})
            if '*' in data[1]:
                currentResolution = {'width':int(width),'height':int(height),'fps':float(fps)}
    return possibleResolutions, currentResolution

Solution

  • Below is a solution that works on Windows (depends on pywin32). There are placeholders where you can put in your existing linux code, I'm not sure what to do about OS X though.

    from __future__ import print_function
    import sys
    
    class ScreenRes(object):
        @classmethod
        def set(cls, width=None, height=None, depth=32):
            '''
            Set the primary display to the specified mode
            '''
            if width and height:
                print('Setting resolution to {}x{}'.format(width, height, depth))
            else:
                print('Setting resolution to defaults')
    
            if sys.platform == 'win32':
                cls._win32_set(width, height, depth)
            elif sys.platform.startswith('linux'):
                cls._linux_set(width, height, depth)
            elif sys.platform.startswith('darwin'):
                cls._osx_set(width, height, depth)
    
        @classmethod
        def get(cls):
            if sys.platform == 'win32':
                return cls._win32_get()
            elif sys.platform.startswith('linux'):
                return cls._linux_get()
            elif sys.platform.startswith('darwin'):
                return cls._osx_get()
    
        @classmethod
        def get_modes(cls):
            if sys.platform == 'win32':
                return cls._win32_get_modes()
            elif sys.platform.startswith('linux'):
                return cls._linux_get_modes()
            elif sys.platform.startswith('darwin'):
                return cls._osx_get_modes()
    
        @staticmethod
        def _win32_get_modes():
            '''
            Get the primary windows display width and height
            '''
            import win32api
            from pywintypes import DEVMODEType, error
            modes = []
            i = 0
            try:
                while True:
                    mode = win32api.EnumDisplaySettings(None, i)
                    modes.append((
                        int(mode.PelsWidth),
                        int(mode.PelsHeight),
                        int(mode.BitsPerPel),
                        ))
                    i += 1
            except error:
                pass
    
            return modes
    
        @staticmethod
        def _win32_get():
            '''
            Get the primary windows display width and height
            '''
            import ctypes
            user32 = ctypes.windll.user32
            screensize = (
                user32.GetSystemMetrics(0), 
                user32.GetSystemMetrics(1),
                )
            return screensize
    
        @staticmethod
        def _win32_set(width=None, height=None, depth=32):
            '''
            Set the primary windows display to the specified mode
            '''
            # Gave up on ctypes, the struct is really complicated
            #user32.ChangeDisplaySettingsW(None, 0)
            import win32api
            from pywintypes import DEVMODEType
            if width and height:
    
                if not depth:
                    depth = 32
    
                mode = win32api.EnumDisplaySettings()
                mode.PelsWidth = width
                mode.PelsHeight = height
                mode.BitsPerPel = depth
    
                win32api.ChangeDisplaySettings(mode, 0)
            else:
                win32api.ChangeDisplaySettings(None, 0)
    
    
        @staticmethod
        def _win32_set_default():
            '''
            Reset the primary windows display to the default mode
            '''
            # Interesting since it doesn't depend on pywin32
            import ctypes
            user32 = ctypes.windll.user32
            # set screen size
            user32.ChangeDisplaySettingsW(None, 0)
    
        @staticmethod
        def _linux_set(width=None, height=None, depth=32):
            raise NotImplementedError()
    
        @staticmethod
        def _linux_get():
            raise NotImplementedError()
    
        @staticmethod
        def _linux_get_modes():
            raise NotImplementedError()
    
        @staticmethod
        def _osx_set(width=None, height=None, depth=32):
            raise NotImplementedError()
    
        @staticmethod
        def _osx_get():
            raise NotImplementedError()
    
        @staticmethod
        def _osx_get_modes():
            raise NotImplementedError()
    
    
    if __name__ == '__main__':
        print('Primary screen resolution: {}x{}'.format(
            *ScreenRes.get()
            ))
        print(ScreenRes.get_modes())
        #ScreenRes.set(1920, 1080)
        #ScreenRes.set() # Set defaults