path: root/displayconfig/displayconfigabstraction.py

#!/usr/bin/env python

import os
import sys
import string
import math
import subprocess
import xf86misc
import xorgconfig
import ScanPCI
import csv
import re
from execwithcapture import *

"""Classes for dealing with X.org configuration in a sane way.

The object model used here is fairly simple. An XSetup object represents
the complete configuration of the server. The XSetup object contains one or
more GfxCard objects. One for each graphics card present in the machine.
Each GfxCard has one or more Screen objects with each Screen representing
one 'output' on the graphics card.

Each GfxCard object is also associated with a GfxCardModel object which
describes the model of graphics card.

Each Screen object is associated with a MonitorModel object which
describes the model of monitor attached.

"""

FALLBACK_RESOLUTION = (800,600)

# FIXME updating /etc/modules for fglrx.
data_file_dir = "."
def SetDataFileDir(dir_name):
    global data_file_dir
    data_file_dir = dir_name

var_data_dir = "/var/lib/guidance-backends"
def SetVarDataDir(dir_name):
    global var_data_dir
    var_data_dir = dir_name

############################################################################
class XSetup(object):
    """Represents the current configuration of the X.org X11 server.


    """
    # Map positions
    ABOVE = 0
    UNDER = 1
    LEFTOF = 2
    RIGHTOF = 3

    RESTART_NONE = 0
    RESTART_X = 1
    RESTART_SYSTEM = 2

    LAYOUT_SINGLE = 1   # These are bit flags.
    LAYOUT_CLONE = 2
    LAYOUT_DUAL = 4
    LAYOUT_SINGLE_XINERAMA = 256    # For internal use.
    LAYOUT_CLONE_XINERAMA = 512     # For internal use.

    POSITION_LEFTOF = 0
    POSITION_RIGHTOF = 1
    POSITION_ABOVE = 2
    POSITION_BELOW = 3

    ROLE_UNUSED = 0
    ROLE_PRIMARY = 1
    ROLE_SECONDARY = 2

    def __init__(self,xorg_config_filename='/etc/X11/xorg.conf',debug_scan_pci_filename=None,secondtry=False):
        self.screens = []
        self.gfxcards = []
        self.xorg_config, self.hasxorg = xorgconfig.readConfig(xorg_config_filename, check_exists=True)
        if not secondtry:
            self.xorg_config_filename = xorg_config_filename
        if self.xorg_config_filename == None:
            self.xorg_config_filename = '/etc/X11/xorg.conf';
        self.x_live_info = xf86misc.XF86Server()

        self.primary_screen = None
        self.secondary_screen = None

        pci_bus = ScanPCI.PCIBus(data_file_dir)
        if debug_scan_pci_filename is None:
            pci_bus.detect()
        else:
            pci_bus.loadFromFile(debug_scan_pci_filename)

        # First thing. Scan the PCI bus and find out how many Gfx cards we have.
        found_list = self._detectGfxCards(pci_bus)
        # list of (PCI_ID, PCIDevice, GfxCard) tuples

        found_list.sort()

        # Prepare some useful data structures.
        self.layout = self.LAYOUT_SINGLE
        self.xinerama = False
        self.orientation = self.POSITION_LEFTOF

        # Maps screen section names to xorg screens section objects.
        xorg_screen_name_dict = {} 
        xorg_unused_screen_sections = self.xorg_config.getSections("Screen")
        for screen in xorg_unused_screen_sections:
            xorg_screen_name_dict[screen.identifier] = screen

        # Maps device sections names to xorg device sections
        xorg_device_name_dict = {}
        xorg_unused_device_sections = self.xorg_config.getSections("Device")
        for device in xorg_unused_device_sections:
            xorg_device_name_dict[device.identifier] = device

        # Maps device sections names to xorg device sections
        xorg_monitor_name_dict = {}
        xorg_monitor_sections = self.xorg_config.getSections("Monitor")
        for monitor in xorg_monitor_sections:
            xorg_monitor_name_dict[monitor.identifier] = monitor

        # Maps GfxCard objects to ScanPCI.PCIDevice objects.
        gfx_card_pcidevice_dict = {}

        #-------------------------------------------------------------------
        # Decode the server layout.
        server_layouts = self.xorg_config.getSections("ServerLayout")
        if len(server_layouts)==0:
            print "*** Error: couldn't find any ServerLayout sections"
            return
        layout = server_layouts[0] # Grab the first ServerLayout

        if len(layout.screen)==0:
            print "*** Error: no screens were specified in the ServerLayout section"

        # Handle leftof rightof below and above.
        (primary_name, secondary_name, layout, self.orientation) = self._decodeServerLayoutScreens(layout.screen)

        screen_list = [primary_name]
        if secondary_name is not None:
            screen_list.append(secondary_name)

        for screen_name in screen_list:
            if screen_name in xorg_screen_name_dict:
                screen_section = xorg_screen_name_dict[screen_name]
                if screen_section.device in xorg_device_name_dict:

                    device_section = xorg_device_name_dict[screen_section.device]

                    # Ok, we've now got a screen section and its device.
                    gfx_card = None

                    if device_section.busid is not None:
                        # Try to match this device to a gfxcard by using the PCI bus ID.
                        bus_id = self._canonicalPCIBusID(device_section.busid)

                        # See if there is already a known gfxcard at this PCI ID.
                        gfx_card = self.getGfxCardByPCIBusID(bus_id)
                        if gfx_card is not None:
                            # Let the gfxcard know that we have another device section for it to manage.
                            gfx_card._addXDevice(device_section)
                            try:
                                xorg_unused_device_sections.remove(device_section)
                            except ValueError:
                                pass
                        else:
                            # Not known, look for a matching pci device instead.
                            for pci_device_tuple in found_list:
                                if pci_device_tuple[0]==bus_id:
                                    # Got a hit, create a  gfxcard object.
                                    gfx_card = GfxCard( self, pci_id=bus_id, \
                                        x_device=device_section, \
                                        detected_model=pci_device_tuple[2])

                                    self.gfxcards.append(gfx_card)
                                    gfx_card_pcidevice_dict[gfx_card] = pci_device_tuple[1]
                                    xorg_unused_device_sections.remove(device_section)
                                    found_list.remove(pci_device_tuple)
                                    break

                    else:

                        # OK, no PCI ID, try matching to a PCI device by X driver name,
                        # or if there is one only gfx card then just grab it.
                        driver_name = device_section.driver
                        for pci_device_tuple in found_list:
                            if pci_device_tuple[2].getDriver()==driver_name \
                                    or pci_device_tuple[2].getProprietaryDriver()==driver_name \
                                    or len(found_list)==1:
                                # Got a hit, create a  gfxcard object.
                                gfx_card = GfxCard( self, pci_id=pci_device_tuple[0], \
                                    x_device=device_section, \
                                    detected_model=pci_device_tuple[2])

                                self.gfxcards.append(gfx_card)
                                gfx_card_pcidevice_dict[gfx_card] = pci_device_tuple[1]
                                xorg_unused_device_sections.remove(device_section)
                                found_list.remove(pci_device_tuple)
                                break

                    if gfx_card is not None:
                        # Look up the monitor section from the monitor name.
                        monitor_section = None
                        monitor_model = None
                        if screen_section.monitor in xorg_monitor_name_dict:
                            monitor_section = xorg_monitor_name_dict[screen_section.monitor]
                            monitor_model = self._matchMonitor(monitor_section)

                        screen = Screen(x_config_screen=screen_section, gfx_card=gfx_card, \
                                    x_config_monitor=monitor_section, monitor_model=monitor_model, \
                                    x_config=self.xorg_config)
                        gfx_card._addScreen(screen)

                        if self.primary_screen is None:
                            self.primary_screen = screen
                        elif self.secondary_screen is None:
                            self.secondary_screen = screen

                        xorg_unused_screen_sections.remove(screen_section)

        if self.primary_screen is not None and self.secondary_screen is not None:
            self.layout = layout

        #-------------------------------------------------------------------
        # Dualhead hardware detection.
        gfx_cards_needing_second_heads = []

        # Detect dualhead ATI cards
        for pci_device in pci_bus.devices:
            if pci_device.text is not None and pci_device.text.find("Secondary")!=-1:

                pci_device_id = "PCI:%i:%i:%i" % (pci_device.pci_bus, pci_device.pci_device, pci_device.pci_function)

                for gfx_card in self.gfxcards:
                    if gfx_card.getPCIBusID() != pci_device_id:
                        # Compare the first two numbers that make up a PCI bus id (e.g. middle part of PCI:1:0:0)
                        if gfx_card.getPCIBusID().split(":")[1:-1] == [str(pci_device.pci_bus),str(pci_device.pci_device)]:
                            if len(gfx_card.getScreens())<2:
                                gfx_cards_needing_second_heads.append(gfx_card)
                                found_list = [x for x in found_list if x[0]!=pci_device_id]
                                break

        # Detect dualhead Intel cards
        for gfx_card in self.gfxcards:
            if gfx_card._getDetectedGfxCardModel().getDriver() in ['i740','i810', 'intel']:
                gfx_card_pci_id = gfx_card.getPCIBusID().split(":")[1:]
                base_pci_id = gfx_card_pci_id[:-1]

                for pci_device in pci_bus.devices:
                    if gfx_card_pci_id != [str(pci_device.pci_bus),str(pci_device.pci_device),str(pci_device.pci_function)]:
                        if base_pci_id == [str(pci_device.pci_bus),str(pci_device.pci_device)]:
                            pci_device_id = "PCI:%i:%i:%i" % (pci_device.pci_bus, pci_device.pci_device, pci_device.pci_function)
                            found_list = [x for x in found_list if x[0]!=pci_device_id]
                            # Try to configure a second head later if not yet available
                            if len(gfx_card.getScreens()) < 2:
                                gfx_cards_needing_second_heads.append(gfx_card)
                            break

        # Detect dualhead nVidia cards
        for gfx_card in self.gfxcards:
            if gfx_card._getDetectedGfxCardModel().getDriver() in ['nv','nvidia']:
                if self._isNVidiaCardDualhead(gfx_card_pcidevice_dict[gfx_card]):
                    if len(gfx_card.getScreens())<2:
                        if gfx_card not in gfx_cards_needing_second_heads:
                            gfx_cards_needing_second_heads.append(gfx_card)
                        continue

        # Detect dualhead Matrox cards. This info is from the Cards+ db.
        for gfx_card in self.gfxcards:
            if (gfx_card._getDetectedGfxCardModel().getMultiHead()>1) and (len(gfx_card.getScreens())<2):
                if gfx_card not in gfx_cards_needing_second_heads:
                    gfx_cards_needing_second_heads.append(gfx_card)

        # Detect laptops. Dualhead/clone mode is standard functionality on laptops.
        # (but can be hard to detect).
        if os.path.isfile('/usr/sbin/laptop-detect'):
            if subprocess.call(['/usr/sbin/laptop-detect'])==0:
                if len(self.gfxcards)!=0:
                    gfx_card = self.gfxcards[0]
                    if gfx_card not in gfx_cards_needing_second_heads and \
                       len(gfx_card.getScreens())<2:
                        gfx_cards_needing_second_heads.append(gfx_card)

        # Match up the second heads with any loose sections in xorg.conf.
        for gfx_card in gfx_cards_needing_second_heads:
            screens = gfx_card.getScreens()
            # Try to find a loose xorg.conf Screen section that also
            # references this gfx card. That is probably the config
            # for the second screen.
            for screen_section in xorg_unused_screen_sections:
                if screen_section.device in xorg_device_name_dict:
                    device_section = xorg_device_name_dict[screen_section.device]

                    # Is this the second screen for the same PCI device aka gfxcard?

                    # Note: even though the second head shows up as a separate PCI ID, the screen
                    # section in xorg.conf still uses the primary PCI ID.
                    if str(device_section.screen)=="1" and \
                            self._canonicalPCIBusID(device_section.busid)==gfx_card.getPCIBusID():

                        # Look up the monitor section from the monitor name.
                        monitor_section = None
                        monitor_model = None
                        if screen_section.monitor in xorg_monitor_name_dict:
                            monitor_section = xorg_monitor_name_dict[screen_section.monitor]
                            monitor_model = self._matchMonitor(monitor_section)

                        gfx_card._addXDevice(device_section)
                        xorg_unused_device_sections.remove(device_section)

                        screen = Screen(x_config_screen=screen_section, gfx_card=gfx_card, \
                                    x_config_monitor=monitor_section, monitor_model=monitor_model, \
                                    x_config=self.xorg_config)
                        gfx_card._addScreen(screen)
                        self.secondary_screen = screen
                        xorg_unused_screen_sections.remove(screen_section)
                        break
            else:
                # Couldn't anything in xorg.conf, just make an empty screen
                screen = Screen(gfx_card=gfx_card, x_config=self.xorg_config)
                gfx_card._addScreen(screen)

        #-------------------------------------------------------------------
        # Handle loose gfx card devices. Check that all PCI gfxcards are accounted for.
        for pci_device_tuple in found_list:

            bus_id = pci_device_tuple[0]
            for device_section in xorg_unused_device_sections:
                if bus_id == self._canonicalPCIBusID(device_section.busid):
                    xorg_unused_device_sections.remove(device_section)
                    break
            else:
                device_section = None

            # Got a hit, create a gfxcard object.
            gfx_card = GfxCard( self, pci_id=pci_device_tuple[0], \
                x_device=device_section, \
                detected_model=pci_device_tuple[2])

            gfx_card_pcidevice_dict[gfx_card] = pci_device_tuple[1]
            self.gfxcards.append(gfx_card)

            screen = None
            # See if this device section is referenced by a screen section.
            # if so, then we grab the screen section.
            if device_section is not None:
                for screen_section in xorg_unused_screen_sections:
                    if screen_section.device==device_section.identifier:

                        # Ok, we have found the screen section, monitor?
                        monitor_section = None
                        monitor_model = None
                        if screen_section.monitor in xorg_monitor_name_dict:
                            monitor_section = xorg_monitor_name_dict[screen_section.monitor]
                            monitor_model = self._matchMonitor(monitor_section)

                        screen = Screen(x_config_screen=screen_section, gfx_card=gfx_card, \
                                    x_config_monitor=monitor_section, monitor_model=monitor_model, \
                                    x_config=self.xorg_config)
                        gfx_card._addScreen(screen)
                        xorg_unused_screen_sections.remove(screen_section)
                        break

            if screen is None:
                # Manually add a screen.
                screen = Screen(gfx_card=gfx_card, x_config=self.xorg_config)
                gfx_card._addScreen(screen)

        #-------------------------------------------------------------------
        # Sort the gfx cards by PCI id.
        def gfxcard_pci_sort(a,b): return cmp(a.getPCIBusID(),b.getPCIBusID())
        self.gfxcards.sort(gfxcard_pci_sort)

        # Hand out some randr live screens
        x_live_screens = self.x_live_info.getScreens()
        i = 0
        for gfx_card in self.gfxcards:
            for screen in gfx_card.getScreens():
                if i<len(x_live_screens) and self.getScreenRole(screen)!=XSetup.ROLE_UNUSED:
                    screen._setXLiveScreen(x_live_screens[i])
                    i += 1

        # Ensure that all of the screen roles have been handed out.
        if self.primary_screen is None:
            for screen in self.getAllScreens():
                if screen is not self.secondary_screen:
                    self.primary_screen = screen
                    break
        if self.secondary_screen is None:
            for screen in self.getAllScreens():
                if screen is not self.primary_screen:
                    self.secondary_screen = screen
                    break

        self._finalizeInit()

        if not self.hasxorg and not secondtry:
            """No xorg.conf, so we need to write a temporary one and reload from that one"""
            self.writeXorgConfig('/tmp/xorg.conf.displayconfig')
            self.__init__(xorg_config_filename='/tmp/xorg.conf.displayconfig',secondtry=True)
        return

    def _finalizeInit(self):
        for gfxcard in self.gfxcards:
            gfxcard._finalizeInit()

        # Check the 'layout' on the gfx cards to detect optimised configs.
        gfxcard = self.primary_screen._getGfxCard()
        if gfxcard._getDetectedLayout()!=XSetup.LAYOUT_SINGLE:
            # Something interesting is going on on this gfx card. The
            # secondary screen is in this case going to actually be the
            # other 'head' on this gfx card.
            if gfxcard.getScreens()[0] is not self.primary_screen:
                self.secondary_screen = gfxcard.getScreens()[0]
            else:
                self.secondary_screen = gfxcard.getScreens()[1]

            self.orientation = gfxcard._getDetectedDualheadOrientation()
            self.setLayout(gfxcard._getDetectedLayout())

        self.setLayout(self.layout) # Propogate any XINERAMA_SINGLE stuff out to the gfxcards.
        self.original_layout = self.layout
        self.original_orientation = self.orientation
        self.original_primary_screen = self.primary_screen
        self.original_secondary_screen = self.secondary_screen

    def _matchMonitor(self,monitor_section):
        monitor_model_db = GetMonitorModelDB()

        model_name = monitor_section.modelname
        if monitor_model_db.getMonitorByName(model_name) is not None:
            monitor_model = monitor_model_db.getMonitorByName(model_name)
        else:

            if monitor_section.getRow('horizsync') is not None and monitor_section.getRow('vertrefresh') is not None:
                # Create a monitor object for the monitor in the xconfig.
                # It is probably a Plug N Play monitor and as such doesn't 
                # appear in our monitor DB.
                monitor_model = monitor_model_db.newCustomMonitor(name=model_name)
                monitor_model.setType(MonitorModel.TYPE_PLUGNPLAY)

                if monitor_section.vendorname is not None:
                    monitor_model.setManufacturer(monitor_section.vendorname)

                monitor_model.setHorizontalSync(' '.join(monitor_section.getRow('horizsync')))
                monitor_model.setVerticalSync(' '.join(monitor_section.getRow('vertrefresh')))

            else:
                # Try detecting the monitor.
                monitor_model = monitor_model_db.detect()

            monitor_model.setDpms("dpms" in monitor_section.option)

        return monitor_model

    def _decodeServerLayoutScreens(self,screens_lines):
        primary_name = None
        secondary_name = None
        layout = XSetup.LAYOUT_SINGLE
        position = XSetup.POSITION_LEFTOF

        for line in screens_lines:
            try:
                i = 1
                if line._row[i].isdigit():  # Skip any screen ID number.
                    i += 1

                screen_name1 = line._row[i]
                if primary_name is None:
                    primary_name = screen_name1
                elif secondary_name is None:
                    secondary_name = screen_name1
                    layout = XSetup.LAYOUT_CLONE
                i += 1

                if line._row[i].isdigit():
                    # Skip absolute coords.
                    i += 2
                else:
                    if line._row[i].lower()=='absolute':
                        # Skip the absolute keyword and coords
                        i += 3

                screen_name2 = line._row[i+1]
                secondary_name = screen_name2

                position = {
                    'leftof': XSetup.POSITION_LEFTOF,
                    'rightof': XSetup.POSITION_RIGHTOF,
                    'above': XSetup.POSITION_ABOVE,
                    'below': XSetup.POSITION_BELOW
                    }[line._row[i].lower()]

                layout = XSetup.LAYOUT_DUAL

                if screen_name1!=primary_name:
                    # Swap the screens around. The primary wasn't given first on this
                    # dualhead screen line.
                    secondary_name = screen_name1
                    position = {
                        XSetup.POSITION_LEFTOF: XSetup.POSITION_RIGHTOF,
                        XSetup.POSITION_RIGHTOF: XSetup.POSITION_LEFTOF,
                        XSetup.POSITION_ABOVE: XSetup.POSITION_BELOW,
                        XSetup.POSITION_BELOW: XSetup.POSITION_ABOVE
                        }[position]

            except IndexError:
                pass
            except KeyError:
                pass

        return (primary_name, secondary_name, layout, position)

    def _detectGfxCards(self,pci_bus):
        """Scans the PCI bus for graphics cards.

        Returns a list of (PCI_ID, PCIDevice, GfxCard) tuples."""
        self.gfx_card_db = GetGfxCardModelDB()
        vesa_model = "VESA driver (generic)"

        # Look for a gfxcard.
        found_list = []
        for pci_device in pci_bus.devices:
            if pci_device.isGfxCard():
                pci_id = "PCI:%i:%i:%i" % (pci_device.pci_bus, pci_device.pci_device, pci_device.pci_function)
                model = None
                try:
                    cardname = pci_device.getModule()
                    if not pci_device.isModuleXorgDriver():
                        cardname = vesa_model
                    model = self.gfx_card_db.getGfxCardModelByName(cardname)
                except KeyError:
                    model = self.gfx_card_db.getGfxCardModelByName(vesa_model)
                found_list.append( (pci_id,pci_device,model) )

        return found_list

    def _canonicalPCIBusID(self,bus_id):
        try:
            parts = bus_id.split(":")
            if parts[0].lower()!="pci":
                return None
            bus = int(parts[1])
            device = int(parts[2])
            function = int(parts[3])
            return "PCI:%i:%i:%i" % (bus,device,function)
        except IndexError:
            return None
        except ValueError:
            return None
        except AttributeError:
            return None

    def _isNVidiaCardDualhead(self,PCIDeviceObject):
        """
        PCIDevice - ScanPCI.PCIDevice

        Returns true if the given nVidia PCI device ID supports dualhead.
        """
        # From Xorg source xc/programs/Xserver/hw/xfree86/drivers/nv/nv_setup.c
        # See line "pNv->twoHeads = "
        #
        NV_ARCH_04 = 0x4
        NV_ARCH_10 = 0x10
        NV_ARCH_20 = 0x20
        NV_ARCH_30 = 0x30
        NV_ARCH_40 = 0x40

        pci_device = PCIDeviceObject.device

        if pci_device & 0xfff0 == 0x00f0:
            return True # FIXME PCIXpress chipsets 

        # These IDs come from the Xorg source. 
        # xc/programs/Xserver/hw/xfree86/drivers/nv/nv_driver.c
        # And should be periodically updated.
        chipset = pci_device & 0x0ff0
        if chipset in [
                0x0100, # GeForce 256
                0x0110, # GeForce2 MX
                0x0150, # GeForce2
                0x0170, # GeForce4 MX
                0x0180, # GeForce4 MX (8x AGP)
                0x01A0, # nForce
                0x01F0]:# nForce2
            architecture = NV_ARCH_10
        elif chipset in [
                0x0200, # GeForce3
                0x0250, # GeForce4 Ti
                0x0280]:# GeForce4 Ti (8x AGP)
            architecture = NV_ARCH_20
        elif chipset in [
                0x0300, # GeForceFX 5800
                0x0310, # GeForceFX 5600
                0x0320, # GeForceFX 5200
                0x0330, # GeForceFX 5900
                0x0340]:# GeForceFX 5700
            architecture = NV_ARCH_30
        elif chipset in [
                0x0040,
                0x00C0,
                0x0120,
                0x0130,
                0x0140,
                0x0160,
                0x01D0,
                0x0090,
                0x0210,
                0x0220,
                0x0230,
                0x0290,
                0x0390]:
            architecture = NV_ARCH_40
        else:
            architecture = NV_ARCH_04

        return (architecture >= NV_ARCH_10) and \
                     (chipset != 0x0100) and \
                     (chipset != 0x0150) and \
                     (chipset != 0x01A0) and \
                     (chipset != 0x0200)

    def _syncXorgConfig(self):

        xinerama_clone = (self.layout==XSetup.LAYOUT_CLONE) and \
            not ((self.secondary_screen._getGfxCard() is self.primary_screen._getGfxCard()) \
            and (self.primary_screen._getGfxCard()._getAvailableLayouts() & XSetup.LAYOUT_CLONE))

        if xinerama_clone:
            # For clone mode with xinerama we copy the screen settings from the primary screen
            # to the secondary screen.
            primary_screen = self.getPrimaryScreen()
            secondary_screen = self.getSecondaryScreen()

            resolution = primary_screen.getAvailableResolutions()[primary_screen.getResolutionIndex()]
            secondary_resolution_index = secondary_screen.getAvailableResolutions().index(resolution)
            secondary_screen.setResolutionIndex(secondary_resolution_index)
            secondary_rates = secondary_screen.getAvailableRefreshRatesForResolution(secondary_resolution_index)
            primary_rate = primary_screen.getAvailableRefreshRates()[primary_screen.getRefreshRateIndex()]

            best_rate_index = 0
            best_score = 1000000
            for i in range(len(secondary_rates)):
                rate = secondary_rates[i]
                score = abs(rate-primary_rate)
                if score < best_score:
                    best_score = score
                    best_rate_index = i

            secondary_screen.setRefreshRateIndex(best_rate_index)

        # Sync up the graphics cards.
        for gfxcard in self.gfxcards:
            gfxcard._syncXorgConfig()

        server_flags_sections = self.xorg_config.getSections("ServerFlags")
        if len(server_flags_sections)!=0:
            server_flags = server_flags_sections[0]
            server_flags.option.removeOptionByName("Xinerama")
        else:
            server_flags = self.xorg_config.makeSection(None,["Section","ServerFlags"])
            self.xorg_config.append(server_flags)

        # Delete any old screen entries in the serverlayout section.
        server_layout = self.xorg_config.getSections("ServerLayout")[0]
        for screen in server_layout.screen[:]:
            server_layout.screen.remove(screen)

        # Add the first Screen row
        screen_id_1 = self.primary_screen._getXorgScreenSection().identifier
        server_layout.screen.append(server_layout.screen.makeLine(None,
            ["0",screen_id_1,"0","0"]))

        # FIXME server_flags -> Option "DefaultServerLayout" "???"
        if self.layout==XSetup.LAYOUT_DUAL or xinerama_clone:
            server_flags.option.append( server_flags.option.makeLine(None,["Xinerama","true"]) )

            # Add the second screen row. This one also has the dual screen
            # orientation info.
            screen_id_2 = self.secondary_screen._getXorgScreenSection().identifier

            if not xinerama_clone:

                position = {XSetup.POSITION_LEFTOF:"RightOf",
                    XSetup.POSITION_RIGHTOF:"LeftOf",
                    XSetup.POSITION_ABOVE:"Below",
                    XSetup.POSITION_BELOW:"Above"}[self.orientation]

                server_layout.screen.append(server_layout.screen.makeLine(None,
                    ["1",screen_id_2,position,screen_id_1]))
            else:
                # Xinerama clone mode. Place the second screen directly on top of the
                # primary screen.
                server_layout.screen.append(server_layout.screen.makeLine(None,
                    ["1",screen_id_2,"0","0"]))

        self.original_layout = self.layout
        self.original_orientation = self.orientation
        self.original_primary_screen = self.primary_screen
        self.original_secondary_screen = self.secondary_screen

    def writeXorgConfig(self,filename):
        self._syncXorgConfig()
        self.xorg_config.writeConfig(filename)

    def xorgConfigToString(self):
        return self.xorg_config.toString()

    def getUsedScreens(self):
        """Returns the list of Screen objects that the current setup is using."""
        if self.layout==XSetup.LAYOUT_SINGLE:
            return [self.primary_screen]
        else:
            return [self.primary_screen, self.secondary_screen]

    def getAllScreens(self):
        """Returns a list of all Screen object."""
        screens = []
        for card in self.gfxcards:
            for screen in card.getScreens():
                screens.append(screen)
        return screens

    def getScreen(self,screenindex):
        return self.getUsedScreens()[screenindex]

    def getGfxCards(self):
        return self.gfxcards[:] # No messin' with the gfx card list.

    def getGfxCardByPCIBusID(self,bus_id):
        for gfxcard in self.gfxcards:
            if gfxcard.getPCIBusID()==bus_id:
                return gfxcard
        return None

    def getPrimaryScreen(self):
        return self.primary_screen

    def getSecondaryScreen(self):
        return self.secondary_screen

    def getScreenRole(self,screen):
        if screen is self.primary_screen:
            return XSetup.ROLE_PRIMARY
        if screen is self.secondary_screen:
            return XSetup.ROLE_SECONDARY
        return XSetup.ROLE_UNUSED

    def setScreenRole(self,screen,role):
        if role==XSetup.ROLE_PRIMARY:
            if screen is self.secondary_screen:
                # Swap the roles around.
                self.secondary_screen = self.primary_screen
                self.primary_screen = screen
            else:
                self.primary_screen = screen

        elif role==XSetup.ROLE_SECONDARY:
            if screen is self.primary_screen:
                # Swap the roles around.
                self.primary_screen = self.secondary_screen
                self.secondary_screen = screen
            else:
                self.secondary_screen = screen
        else:
            # ROLE_UNUSED
            if screen is not self.primary_screen and screen is not self.secondary_screen:
                return

            # Find the first screen unused.
            for unused_screen in self.getAllScreens():
                if screen is not self.primary_screen and screen is not self.secondary_screen:
                    if screen is self.primary_screen:
                        self.primary_screen = unused_screen
                    else:
                        self.secondary_screen = unused_screen
                    return

    def mayModifyXorgConfig(self):
        """Check if the current user may modify the xorg.conf file

        Returns True or False
        """
        return os.access(self.xorg_config_filename, os.W_OK|os.R_OK)

    def mayModifyGamma(self):
        """Check if the current user may modify the gamma settings.

        Returns True or False.
        """
        return self.isGammaLive() or self.mayModifyXorgConfig()

    def mayModifyResolution(self):
        """Check if the current user may modify the screen resolution.

        Returns True or False.
        """
        for screen in self.x_live_info.getScreens():
            if screen.resolutionSupportAvailable():
                return True

        return self.mayModifyXorgConfig()

    def isGammaLive(self):
        """Check if gamma changes are done immediately.

        Returns True or False.
        """
        return True     # FIXME depends on the xvid extension and if86misc.

    def isLiveResolutionConfigChanged(self):
        """Check if the live server configuration is changed

        Checks if the configuration has been modified with changes that can be
        pushed to the running X server.

        Returns True or False.
        """
        # XRandR tends to break Xinerama
        if self.primary_screen._getGfxCard().getLayout() in \
           (XSetup.LAYOUT_SINGLE_XINERAMA, XSetup.LAYOUT_DUAL):
            return False
        for screen in self.getAllScreens():
            if screen.isLive() and screen.isResolutionSettingsChanged():
                return True

        return False

    def applyLiveResolutionChanges(self):
        """Apply any changes that can be done live

        Returns True if running server resolution has been changed.
        """
        rc = False
        for s in self.getUsedScreens():
            if s.isResolutionSettingsChanged():
                s.applyResolutionSettings()
                rc = rc or s.isResolutionLive()
        return rc

    def acceptLiveResolutionChanges(self):
        """


        """
        for s in self.getUsedScreens():
            s.acceptResolutionSettings()

    def rejectLiveResolutionChanges(self):
        """Rejects and reverts the last live server resolution changes

        Rejects the last resolution changes that were made to the live server
        and reverts it back to the previous configuration.
        """
        for s in self.getUsedScreens():
            s.revertResolutionSettings()

    def isLiveGammaConfigChanged(self):
        """Check if the live server gamma configuration is changed

        Checks if the configuration has been modified with changes that can be
        pushed to the running X server.

        Returns True or False.
        """
        for screen in self.getAllScreens():
            if screen.isLive() and screen.isGammaSettingsChanged():
                return True

        return False

    def applyLiveGammaChanges(self):
        """Apply any changes that can be done live

        Returns True if running server gamma has been changed.
        """
        rc = False
        for s in self.getUsedScreens():
            if s.isGammaSettingsChanged():
                s.applyGammaSettings()
                rc = rc or s.isGammaLive()
        return rc

    def acceptLiveGammaChanges(self):
        """


        """
        for s in self.getUsedScreens():
            s.acceptGammaSettings()

    def rejectLiveGammaChanges(self):
        """Rejects and reverts the last live server gamma changes

        Rejects the last gamma changes that were made to the live server
        and reverts it back to the previous configuration.
        """
        for s in self.getUsedScreens():
            s.revertGammaSettings()

    def isXorgConfigChanged(self):
        """Check if the xorg.config needs to updated

        Returns True if the xorg.config file needs to updated to reflect new changes.
        """
        changed = self.original_layout!=self.layout or \
                    self.original_orientation!=self.orientation or \
                    self.original_primary_screen!=self.primary_screen or \
                    self.original_secondary_screen!=self.secondary_screen

        for gfxcard in self.gfxcards:
            changed = changed or gfxcard.isXorgConfigChanged()
        for screen in self.getAllScreens():
            changed = changed or screen.isXorgConfigChanged()
        return changed

    def getRestartHint(self):
        hint = XSetup.RESTART_NONE
        if self.original_layout!= self.layout or self.original_orientation != self.orientation:
            hint = XSetup.RESTART_X
        return max(hint,max( [gfxcard.getRestartHint() for gfxcard in self.gfxcards] ))

    def reset(self):
        for card in self.gfxcards:
            card.reset()

        self.layout = self.original_layout
        self.orientation = self.original_orientation
        self.primary_screen = self.original_primary_screen
        self.secondary_screen = self.original_secondary_screen

    # Dualhead and secondary monitor support ----------
    def getLayout(self):
        return self.layout

    def setLayout(self,layout):
        """

        Keyword arguments:
        layout - XSetup.LAYOUT_SINGLE, XSetup.LAYOUT_CLONE or XSetup.LAYOUT_DUAL.
        """
        self.layout = layout

        if self.layout==XSetup.LAYOUT_SINGLE:
            for gfxcard in self.gfxcards:
                gfxcard.setLayout(XSetup.LAYOUT_SINGLE)
            self.xinerama = False
        elif self.layout==XSetup.LAYOUT_DUAL:
            # 'xinerama' screens can be combined by the ServerLayout xorg.conf
            # sections into a multihead configurations. Gfxcard objects just
            # have to output xinerama friendly xorg.conf device and screen
            # sections.
            self.xinerama = True
            for gfxcard in self.gfxcards:
                gfxcard.setLayout(XSetup.LAYOUT_SINGLE_XINERAMA)

            # Check if the primary and secondary screen are on the same gfx card.
            # If so then see if the gfxcard can directly (read: accelarated) support
            # the layout we want.
            if self.primary_screen._getGfxCard() is self.secondary_screen._getGfxCard():
                if self.primary_screen._getGfxCard().getAvailableLayouts() & self.layout:
                    self.primary_screen._getGfxCard().setLayout(self.layout)
                    self.xinerama = False

        elif self.layout==XSetup.LAYOUT_CLONE:

            # If the graphics card itself has both heads and it can offer a better clone
            # mode, then we use that instead of faking it with xinerama.
            if (self.secondary_screen._getGfxCard() is self.primary_screen._getGfxCard()) \
                    and (self.primary_screen._getGfxCard()._getAvailableLayouts() & XSetup.LAYOUT_CLONE):
                self.xinerama = False
                for gfxcard in self.gfxcards:
                    gfxcard.setLayout(XSetup.LAYOUT_CLONE)
            else:
                self.xinerama = True
                for gfxcard in self.gfxcards:
                    gfxcard.setLayout(XSetup.LAYOUT_SINGLE_XINERAMA)

    def mayModifyLayout(self):
        return self.mayModifyXorgConfig()

    def getAvailableLayouts(self):
        if self.secondary_screen is not None:
            return XSetup.LAYOUT_SINGLE | XSetup.LAYOUT_DUAL | XSetup.LAYOUT_CLONE
        else:
            return XSetup.LAYOUT_SINGLE

    def setDualheadOrientation(self,orientation):
        """ Sets orientation of monitor to one of 
            XSetup.ABOVE, XSetup.UNDER, XSetup.LEFTOF, XSetup.RIGHTOF
        """
        self.orientation = orientation

    def getDualheadOrientation(self):
        """ Returns the current orientation, one of 
            XSetup.ABOVE, XSetup.UNDER, XSetup.LEFTOF, XSetup.RIGHTOF
        """
        return self.orientation

    def isHWAccelerated(self):
        # FIXME:
        # if twinview-alike and screen[0].res = screen[1].res
        # else: if primary screen
        return True

    # Internal ----------
    def _addScreen(self,screen):
        self.screens.append(screen)

    def _addGfxCard(self,gfxcard):
        self.gfxcards.append(gfxcard)

    def _getColorDepth(self):
        return min([s._getColorDepth() for s in self.getUsedScreens()])

    def __str__(self):
        string = "XSetup:\n"
        string += "    Layout: %s\n" % ({self.LAYOUT_SINGLE: "Single",
            self.LAYOUT_CLONE: "Clone",
            self.LAYOUT_DUAL: "Dual"
            }[self.getLayout()])

        i = 1
        for gfxcard in self.gfxcards:
            string += "    Gfxcard %i: %s\n" % (i,str(gfxcard))
            i += 1
        return string

############################################################################
class GfxCard(object):
    """Represents a graphics card that is present in this computer."""

    def __init__(self, setup, pci_id=None, x_device=None, detected_model=None, proprietary_driver=False):
        self.setup = setup
        self.x_config = self.setup.xorg_config
        self.layout = XSetup.LAYOUT_SINGLE
        self.pci_id = pci_id
        self.screens = []

        self.detected_model = detected_model
        self.proprietary_driver = proprietary_driver 

        self.video_ram = 1024

        # The (optimised) layout that was detected in xorg.conf on device level.
        self.detected_layout = XSetup.LAYOUT_SINGLE
        self.detected_orientation = XSetup.POSITION_LEFTOF

        self.x_device = []  # This can be a list of xorg device sections
        if x_device is not None:
            self.x_device.append(x_device)

    def _addScreen(self,screen):
        self.screens.append(screen)

    def _addXDevice(self,x_device):
        self.x_device.append(x_device)

    def _finalizeInit(self):
        # Finish initalisation.

        if len(self.x_device)!=0:

            # Try to find a gfx card model.
            self.gfxcard_model = None
            if self.x_device[0].boardname is not None:
                # Look up the model by boardname.
                try:
                    self.gfxcard_model = GetGfxCardModelDB().getGfxCardModelByName(self.x_device[0].boardname)
                except KeyError:
                    pass

            if self.gfxcard_model is None:
                # OK, try looking it up by driver.
                try:
                    self.gfxcard_model = GetGfxCardModelDB().getGfxCardModelByDriverName(self.x_device[0].driver)
                except KeyError:
                    self.gfxcard_model = self.detected_model

            # Write the current driver in the model
            if self.x_device[0].driver:
                self.gfxcard_model.setDriver(self.x_device[0].driver)

            self.proprietary_driver = self.gfxcard_model.getProprietaryDriver()==self.x_device[0].driver

            if self.x_device[0].videoram is not None:
                self.video_ram = int(self.x_device[0].videoram)

            # Detect layout
            if len(self.screens)>=2:
                # Xorg ATI driver.
                if self._getCurrentDriver() in ['ati','r128','radeon']:
                    merged = self.x_device[0].option.getOptionByName('mergedfb')
                    if merged is not None and xorgconfig.toBoolean(merged._row[2]):
                        self.detected_layout = XSetup.LAYOUT_CLONE
                # ATI proprietary driver
                elif self._getCurrentDriver()=='fglrx':
                    desktopsetup = self.x_device[0].option.getOptionByName('desktopsetup')
                    if desktopsetup is not None and desktopsetup._row[2]=='c':
                        self.detected_layout = XSetup.LAYOUT_CLONE
                # nVidia proprietary driver
                elif self._getCurrentDriver()=='nvidia':
                    twinview = self.x_device[0].option.getOptionByName('twinview')
                    if twinview is not None:
                        desktopsetup = self.x_device[0].option.getOptionByName('twinvieworientation')
                        if desktopsetup is not None and desktopsetup._row[2].lower()=='clone':
                            self.detected_layout = XSetup.LAYOUT_CLONE
                # i810 driver
                elif self._getCurrentDriver() in ['i810', 'intel']:
                    clone = self.x_device[0].option.getOptionByName('clone')
                    if clone is not None:
                        if xorgconfig.toBoolean(clone._row[2]):
                            self.detected_layout = XSetup.LAYOUT_CLONE

        else:
            self.gfxcard_model = self.detected_model

        self.original_gfxcard_model = self.gfxcard_model
        self.original_proprietary_driver = self.proprietary_driver
        self.original_layout = self.layout

        # Give the screens a chance to finish initialisation.
        for screen in self.screens:
            screen._finalizeInit()
        for screen in self.screens:
            screen._resyncResolution()

    def _getDetectedLayout(self):
        return self.detected_layout

    def _getDetectedDualheadOrientation(self):
        return self.detected_orientation

    def _getDetectedGfxCardModel(self):
        return self.detected_model

    def getScreens(self):
        return self.screens[:]

    def getGfxCardModel(self):
        return self.gfxcard_model

    def setGfxCardModel(self,gfx_card_model):
        self.gfxcard_model = gfx_card_model

        for screen in self.screens:
            screen._resyncResolution()

    def getXorgDeviceSection(self,index):
        return self.x_device[index]

    def isProprietaryDriver(self):
        return self.proprietary_driver

    def setProprietaryDriver(self,proprietary_driver):
        self.proprietary_driver = proprietary_driver

    def getDetectedGfxCardModel(self):
        return self.detected_model

    def getPCIBusID(self):
        return self.pci_id

    def isXorgConfigChanged(self):
        return self.original_gfxcard_model is not self.gfxcard_model or \
            self.original_proprietary_driver != self.proprietary_driver or \
            self.original_layout != self.layout

    def reset(self):
        for screen in self.screens:
            screen.reset()

        self.gfxcard_model = self.original_gfxcard_model
        self.proprietary_driver = self.original_proprietary_driver

    def isAGP(self):
        return self.pci_id=='PCI:1:0:0' # FIXME this might not be accurate.

    def getLayout(self):
        return self.layout

    def setLayout(self,layout):
        self.layout = layout
        for screen in self.screens:
            screen._resyncResolution()

    def getAvailableLayouts(self):
        layouts = XSetup.LAYOUT_SINGLE
        if len(self.screens)==2:
            if self._getCurrentDriver() in ['fglrx', 'nvidia', 'i810']:
                layouts |= XSetup.LAYOUT_CLONE | XSetup.LAYOUT_DUAL
        return layouts

    def getVideoRam(self):
        """
        Get the amount of video ram that this card has.

        The values returned have the following meanings:
            256 => 256 kB
            512 => 512 kB
            1024 => 1 MB
            2048 => 2 MB
            4096 => 4 MB
            8192 => 8 MB
            16384 => 16 MB
            32768 => 32 MB
            65536 => 64 MB or more

        The video ram setting is only used if the selected graphics card model requires
        that the amount of video ram be explicitly specified. That is to say that
        gfxcard.getGfxCardModel().getNeedVideoRam() returns true.

        Returns an integer from the list above.
        """
        return self.video_ram

    def setVideoRam(self,ram):
        self.video_ram = ram

        for screen in self.screens:
            screen._resyncResolution()

    def _getCurrentDriver(self):
        if self.proprietary_driver:
            return self.gfxcard_model.getProprietaryDriver()
        else:
            return self.gfxcard_model.getDriver()

    def getRestartHint(self):
        # The ATI propreitary drivers need a special AGP kernel module to be loaded.
        # The best, and often only way to get this module loaded is to reboot.
        # The same applies for removing the module.
        hint = XSetup.RESTART_NONE

        if self.original_proprietary_driver:
            original_gfx_driver = self.original_gfxcard_model.getProprietaryDriver()
        else:
            original_gfx_driver = self.original_gfxcard_model.getDriver()

        current_gfx_driver = self._getCurrentDriver()

        if current_gfx_driver!=original_gfx_driver:
            # Restart X if the driver is different.
            hint = XSetup.RESTART_X

        # Layout changes also require an X server restart.
        if self.original_layout!=self.layout:
            hint = XSetup.RESTART_X

        if original_gfx_driver=='fglrx' and current_gfx_driver in ['ati','r128','radeon']:
            hint = XSetup.RESTART_SYSTEM

        # If a different kernel module is needed, then restart the system.
        kernel_module_list = self._getLoadedKernelModules()
        if self._needATIFglrx() and 'fglrx' not in kernel_module_list:
            hint = XSetup.RESTART_SYSTEM
        else:
            if 'fglrx' in kernel_module_list:
                hint = XSetup.RESTART_SYSTEM

        hintlist = [hint]
        hintlist.extend([screen.getRestartHint() for screen in self.screens])
        return max(hintlist)

    def _needATIFglrx(self):
        """Work out if the current configuration require the ATI fglrx kernel module."""
        return self.isAGP() and self.getGfxCardModel() is not None and \
            self.getGfxCardModel().getProprietaryDriver()=='fglrx' and self.isProprietaryDriver()

    def _getLoadedKernelModules(self):
        return [line.split()[0] for line in open('/proc/modules')]

    def _getAvailableLayouts(self):
        if len(self.screens)>=2:
            drv = self._getCurrentDriver()
            layouts = XSetup.LAYOUT_SINGLE | XSetup.LAYOUT_DUAL
            if drv in ['fglrx', 'nvidia', 'i810']:
                layouts |= XSetup.LAYOUT_CLONE
            elif drv in ['ati', 'radeon', 'r128', 'intel']:
                layouts = XSetup.LAYOUT_SINGLE
            return layouts
        else:
            return XSetup.LAYOUT_SINGLE

    def __str__(self):
        screen_string = ",".join([str(s) for s in self.screens])
        driver = self._getCurrentDriver()
        return "GfxCard: {model:"+str(self.gfxcard_model)+", driver:"+driver+", screens:"+screen_string+"}"

    def _syncXorgConfig(self):
        if self.proprietary_driver and self.gfxcard_model.getProprietaryDriver() is not None:
            driver = self.gfxcard_model.getProprietaryDriver()
        else:
            driver = self.gfxcard_model.getDriver()

        # FIXME maybe this module stuff should migrate into XSetup.

        # --- Fix the module section ---

        # $raw_X->set_devices($card, @{$card->{cards} || []});
        # $raw_X->get_ServerLayout->{Xinerama} = { commented => !$card->{Xinerama}, Option => 1 }
        #if defined $card->{Xinerama};
        module_sections = self.x_config.getSections("Module")
        if len(module_sections) > 0:
            module = module_sections[0]
        else:
            module = self.x_config.makeSection(None, ["Section", "Module"])
            self.x_config.append(module)

        module.removeModule('GLcore')
        module.removeModule('glx')
        module.removeModule('dbe')

        # Mandriva
        #module.removeModule("/usr/X11R6/lib/modules/extensions/libglx.so")

        if driver=='nvidia':
            module.addModule("glx")

            # Mandriva
            # This loads the NVIDIA GLX extension module.
            # IT IS IMPORTANT TO KEEP NAME AS FULL PATH TO libglx.so ELSE
            # IT WILL LOAD XFree86 glx module and the server will crash.

            # module.addModule("/usr/X11R6/lib/modules/extensions/libglx.so")
            # FIXME lib64
        elif self.gfxcard_model.getProprietaryDriver()!='fglrx':
            module.addModule('glx')
            module.addModule('GLcore')

        #module.removeModule("/usr/X11R6/lib/modules/extensions/libglx.a")
        if driver=='fglrx':
            module.addModule("glx")
            module.addModule("dbe")
        #elif driver!='nvidia':
        #    module.addModule("/usr/X11R6/lib/modules/extensions/libglx.a")

        # DRI
        module.removeModule('dri')
        if self.gfxcard_model.getDriGlx():
            module.addModule('dri')

        module.removeModule('v4l')
        if not (self.gfxcard_model.getDriGlx() and self.gfxcard_model.getDriver()=='r128'):
            module.addModule('v4l')

        # --- Fix all of the Device sections ---
        for i in range(len(self.screens)):

            if i==len(self.x_device):
                new_device = self.x_config.makeSection('',['section','device'])
                self.x_config.append(new_device)
                self.x_device.append(new_device)
                new_device.identifier = self.x_config.createUniqueIdentifier("device")

            identifier = self.x_device[i].identifier
            busid = self.x_device[i].busid

            self.x_device[i].clear()

            # Create a new Device section in the Xorg config file.
            self.x_device[i].identifier = identifier
            self.x_device[i].boardname = self.gfxcard_model.getName()
            self.x_device[i].busid = self.pci_id
            self.x_device[i].driver = driver
            self.x_device[i].screen = str(i)

            if self.gfxcard_model.getVendor() is not None:
                self.x_device[i].vendorname = self.gfxcard_model.getVendor()

            if self.gfxcard_model.getNeedVideoRam():
                self.x_device[i].videoram = self.video_ram

            # Setup Clone mode for second heads.
            if driver in ["ati","r128","radeon"]:   # Xorg ATI driver
                merged_value = {
                    XSetup.LAYOUT_CLONE: "on",
                    XSetup.LAYOUT_SINGLE: "off",
                    XSetup.LAYOUT_DUAL: "on",
                    XSetup.LAYOUT_SINGLE_XINERAMA: "off"
                    }[self.layout]

                merged_option = self.x_device[i].option.makeLine(None,["MergedFB",merged_value])
                self.x_device[i].option.append(merged_option)

                if self.layout==XSetup.LAYOUT_CLONE:
                    monitor_model = self.setup.getSecondaryScreen().getMonitorModel()
                    if monitor_model is not None:
                        if monitor_model.getHorizontalSync() is not None:
                            hsyncline = self.x_device[i].option.makeLine(None,['CRT2HSync',monitor_model.getHorizontalSync()])
                            self.x_device[i].option.append(hsyncline)

                        if monitor_model.getVerticalSync() is not None:
                            vsyncline = self.x_device[i].option.makeLine(None,['CRT2VRefresh',monitor_model.getVerticalSync()])
                            self.x_device[i].option.append(vsyncline)

                # FIXME option "CloneMode" "off"

            if driver=='fglrx': # ATI proprietary driver.
                if self.layout==XSetup.LAYOUT_CLONE:
                    new_option = self.x_device[i].option.makeLine(None,["DesktopSetup","c"])
                    self.x_device[i].option.append(new_option)

                    # FIXME this probably won't work on laptops and DVI. The user will probably
                    # have to manually select the monitor types.

                    # We do this to make sure that the driver starts up in clone mode even
                    # if it can't detect the second monitor.
                    new_option = self.x_device[i].option.makeLine(None,["ForceMonitors","crt1,crt2"])
                    self.x_device[i].option.append(new_option)

                    monitor_model = self.setup.getSecondaryScreen().getMonitorModel()
                    if monitor_model is not None:
                        if monitor_model.getHorizontalSync() is not None:
                            hsyncline = self.x_device[i].option.makeLine(None,['HSync2',monitor_model.getHorizontalSync()])
                            self.x_device[i].option.append(hsyncline)

                        if monitor_model.getVerticalSync() is not None:
                            vsyncline = self.x_device[i].option.makeLine(None,['VRefresh2',monitor_model.getVerticalSync()])
                            self.x_device[i].option.append(vsyncline)

            if driver=='nvidia':    # nVidia proprietary driver.
                if self.layout==XSetup.LAYOUT_CLONE:
                    new_option = self.x_device[i].option.makeLine(None,["TwinView","on"])
                    self.x_device[i].option.append(new_option)
                    new_option = self.x_device[i].option.makeLine(None,["TwinViewOrientation","clone"])
                    self.x_device[i].option.append(new_option)

                    monitor_model = self.setup.getSecondaryScreen().getMonitorModel()
                    if monitor_model is not None:
                        if monitor_model.getHorizontalSync() is not None:
                            hsyncline = self.x_device[i].option.makeLine(None,['SecondMonitorHorizSync',monitor_model.getHorizontalSync()])
                            self.x_device[i].option.append(hsyncline)

                        if monitor_model.getVerticalSync() is not None:
                            vsyncline = self.x_device[i].option.makeLine(None,['SecondMonitorVertRefresh',monitor_model.getVerticalSync()])
                            self.x_device[i].option.append(vsyncline)

            if driver in ['i810']:  # i810 driver
                if self.layout in (XSetup.LAYOUT_SINGLE_XINERAMA,
                                   XSetup.LAYOUT_DUAL,
                                   XSetup.LAYOUT_CLONE):
                    new_option = self.x_device[i].option.makeLine(None,["MonitorLayout", "CRT,LFP"])
                    self.x_device[i].option.append(new_option)
                if self.layout==XSetup.LAYOUT_CLONE:
                    new_option = self.x_device[i].option.makeLine(None,["Clone","on"])
                    self.x_device[i].option.append(new_option)

                    # Find the closest matching refresh rate for the second monitor.
                    primary_screen = self.setup.getPrimaryScreen()
                    secondary_screen = self.setup.getSecondaryScreen()
                    resolution = primary_screen.getAvailableResolutions()[primary_screen.getResolutionIndex()]
                    secondary_resolution_index = secondary_screen.getAvailableResolutions().index(resolution)
                    secondary_rates = secondary_screen.getAvailableRefreshRatesForResolution(secondary_resolution_index)
                    primary_rate = primary_screen.getAvailableRefreshRates()[primary_screen.getRefreshRateIndex()]

                    best_rate = 50
                    best_score = 1000000
                    for rate in secondary_rates:
                        score = abs(rate-primary_rate)
                        if score < best_score:
                            best_score = score
                            best_rate = rate

                    # Specify a working refresh rate for the second monitor.
                    new_option = self.x_device[i].option.makeLine(None,["CloneRefresh",str(best_rate)])
                    self.x_device[i].option.append(new_option)

            self._insertRawLinesIntoConfig(self.x_device[i], self.gfxcard_model.getLines())

            self.screens[i]._syncXorgConfig(self.x_device[i])

        self.original_gfxcard_model = self.gfxcard_model
        self.original_proprietary_driver = self.proprietary_driver
        self.original_layout = self.layout

    def _insertRawLinesIntoConfig(self,section,lines):
        reader = csv.reader(lines,delimiter=' ')
        for row in reader:
            if len(row)>=2:
                if row[0].lower()=="option":
                    option = section.option.makeLine(None,row[1:])
                    section.option.append(option)

############################################################################
class Screen(object):
    """Represents a single output/screen/monitor on a graphics card.

    Changes to the screen resolution, refresh rate, rotation and reflection
    settings are not made active until the method applyResolutionSettings() is
    called. After calling applyResolutionSettings(), changes can be backed out
    of with the revertResolutionSettings() method. If you, should I say the user,
    is satisfied with the new settings then call the acceptResolutionSettings()
    method.

    Gamma correction settings take effect immediately, and don't take part in the
    apply, revert and accept mechanism above.
    """

    RR_Rotate_0 = xf86misc.XF86Screen.RR_Rotate_0
    RR_Rotate_90 = xf86misc.XF86Screen.RR_Rotate_90
    RR_Rotate_180 = xf86misc.XF86Screen.RR_Rotate_180
    RR_Rotate_270 = xf86misc.XF86Screen.RR_Rotate_270
    RR_Reflect_X = xf86misc.XF86Screen.RR_Reflect_X
    RR_Reflect_Y = xf86misc.XF86Screen.RR_Reflect_Y

    def __init__(self, gfx_card=None, x_config_screen=None, x_config_monitor=None, \
                    monitor_model=None, x_config=None):
        """Create a Screen object.

        This method is private to this module.
        """
        self.gfx_card = gfx_card
        self.x_config_screen = x_config_screen

        self.x_config_monitor = x_config_monitor
        self.monitor_model = monitor_model
        self.monitor_aspect = ModeLine.ASPECT_4_3
        self.original_monitor_model = monitor_model
        self.x_config = x_config

        # Cookup some sensible screen sizes.
        self.standard_sizes = GetMonitorModeDB().getAllResolutions()

        self.x_live_screen = None

        # Intialise the gamma settings with defaults.
        self.redgamma = 1.0
        self.greengamma = 1.0
        self.bluegamma = 1.0
        self.allgamma = 1.0
        self.settingall = True

        # If there is a monitor xorg.conf section then look there for gamma info.
        if self.x_config_monitor is not None:
            gamma_row = self.x_config_monitor.getRow('gamma')
            if gamma_row is not None:
                # Read the gamma info out of xorg.conf
                try:
                    if len(gamma_row)==3:
                        self.redgamma = float(gamma_row[0])
                        self.greengamma = float(gamma_row[1])
                        self.bluegamma = float(gamma_row[2])
                        self.allgamma = self.redgamma
                    elif len(gamma_row)==1:
                        self.allgamma = float(gamma_row[0])
                        self.redgamma = self.allgamma
                        self.greengamma = self.allgamma
                        self.bluegamma = self.allgamma
                except ValueError:
                    pass

            # Try to work out if this monitor is setup for 4:3 modes or 16:9.
            aspect_43_count = 0
            aspect_169_count = 0
            # Count the number of 4:3 modelines compared to 16:9 modes.
            for mode in self.x_config_monitor.modeline:
                try:
                    # Don't count the fallback resolution. It is also present
                    # if the monitor is widescreen. Just ignore it.
                    if (mode._row[2],mode._row[6])!=FALLBACK_RESOLUTION:
                        if MonitorModeDB.aspectRatio(mode._row[2],mode._row[6])==ModeLine.ASPECT_4_3:
                            aspect_43_count += 1
                        else:
                            aspect_169_count += 1
                except IndexError:
                    pass

            if aspect_43_count >= aspect_169_count:
                self.monitor_aspect = ModeLine.ASPECT_4_3
            else:
                self.monitor_aspect = ModeLine.ASPECT_16_9

        # Backup the settings
        (self.originalredgamma, self.originalgreengamma, self.originalbluegamma) = (
            self.redgamma, self.greengamma, self.bluegamma)
        self.originalallgamma = self.allgamma
        self.originalsettingall = self.settingall
        self.original_monitor_aspect = self.monitor_aspect

    def _setXLiveScreen(self,x_live_screen):
        self.x_live_screen = x_live_screen

    def _finalizeInit(self):

        if self.x_live_screen is not None and self.x_live_screen.resolutionSupportAvailable():
            self._computeSizesFromXorg()

            (cw,ch,x,x) = self.x_live_screen.getSize()
            i = 0
            self.currentsizeindex = 0
            for size in self.available_sizes:
                if (cw,ch)==size:
                    self.currentsizeindex = i
                    break
                i += 1

            self.currentrefreshrate = self.x_live_screen.getRefreshRate()
            self.currentrotation = self.x_live_screen.getRotation() & (
                Screen.RR_Rotate_0 | Screen.RR_Rotate_90 | Screen.RR_Rotate_180 | Screen.RR_Rotate_270)
            self.currentreflection = self.x_live_screen.getRotation() & (
                                        Screen.RR_Reflect_X | Screen.RR_Reflect_Y)

        else:
            # There is no live info, so try to collect some info out
            # of xorg.conf itself.

            # Cookup some reasonable screen resolutions based on what we know about the monitor.
            self._computeSizesFromMonitor()

            (cw,ch) = self.available_sizes[0]
            self.currentrefreshrate = None

            # Dig through the Display sections in the xorg.conf Screen section
            # and try to find the first resolution/mode.
            if self.x_config_screen is not None:
                default_depth = self.x_config_screen.defaultdepth

                current_mode_name = None

                for display_section in self.x_config_screen.getSections('display'):
                    if default_depth is None or display_section.depth==default_depth:
                        modes_row = display_section.getRow('modes')
                        if modes_row is not None and len(modes_row)>=1:
                            current_mode_name = modes_row[0]
                            break

                if current_mode_name is not None:
                    for mode in self.mode_list:
                        if mode.getName()==current_mode_name:
                            cw = mode.getWidth()
                            ch = mode.getHeight()
                            self.currentrefreshrate = mode.getVRefresh()
                            break

            # Work out the index of the current resolution 
            i = 0
            for size in self.available_sizes:
                if (cw,ch)==size:
                    self.currentsizeindex = i
                    break
                i += 1

            if self.currentrefreshrate is None:
                self.currentrefreshrate = self.getAvailableRefreshRates()[0]

            self.currentrotation = Screen.RR_Rotate_0   # FIXME
            self.currentreflection = 0                  # FIXME

        # Gamma settings
        if self.x_live_screen is not None:
            try:
                (self.redgamma, self.greengamma, self.bluegamma, self.allgama, 
                 self.settingall) = self._getGammaFromLiveScreen()
            except:
                (self.redgamma, self.greengamma, self.bluegamma, self.allgama, 
                 self.settingall) = self._getGammaFromXorg()
        else:
            (self.redgamma, self.greengamma, self.bluegamma, self.allgama, 
             self.settingall) = self._getGammaFromXorg()

        self.originalsizeindex = self.currentsizeindex
        self.original_size = self.getAvailableResolutions()[self.currentsizeindex]
        self.originalrefreshrate = self.currentrefreshrate
        self.originalrotation = self.currentrotation
        self.originalreflection = self.currentreflection

        self.originalredgamma = self.redgamma
        self.originalgreengamma = self.greengamma
        self.originalbluegamma = self.bluegamma

        self.originalallgamma = self.allgamma
        self.originalsettingall = self.settingall

    def _getGammaFromLiveScreen(self):
        """Reads the gamma information from the x server"""
        # Read the current gamma settings directly from X.
        (redgamma, greengamma, bluegamma) = self.x_live_screen.getGamma()

        # Round the values off to 2 decimal places.
        redgamma = round(self.redgamma,2)
        greengamma = round(self.greengamma,2)
        bluegamma = round(self.bluegamma,2)

        allgamma = redgamma
        settingall = redgamma==greengamma==bluegamma
        return (redgamma, greengamma, bluegamma, allgamma, settingall)

    def _getGammaFromXorg(self):
        """Extracts the gamma information from the xorg configuration"""
        # Set some gamma defaults
        redgamma = greengamma = bluegamma = allgamma = 1.0
        settingall = True

        # Look for gamma information in xorg.conf
        if self.x_config_monitor is not None:
            gamma_row = self.x_config_monitor.getRow('gamma')
            if gamma_row is not None:
                try:
                    if len(gamma_row)==1:
                        allgamma = float(gamma_row[0])
                        redgamma = greengamma = bluegamma = allgamma
                        self.settingall = True
                    elif len(gamma_row.row)==3:
                        redgamma = float(gamma_row[0])
                        greengamma = float(gamma_row[1])
                        bluegamma = float(gamma_row[2])
                        allgamma = self.redgamma
                        settingall = False
                except ValueError:
                    pass
        return (redgamma, greengamma, bluegamma, allgamma, settingall)

    def _computeSizesFromXorg(self):
        all_sizes = self.x_live_screen.getAvailableSizes()
        self.available_sizes = []

        # Some dualhead setups repolonger sizelists, those are unlikely 
        # to be standard zes, we still want to be able to use them.s
        for i in range(len(all_sizes)):
            if len(all_sizes[i]) > 2:
                self.available_sizes.append(all_sizes[i][:2])
            elif len(alls_sizes[i]) == 2:
                if (size[0],size[1]) in self.standard_sizes:
                    self.available_sizes.append(all_sizes[i])
        self.available_sizes.sort()

    def _computeSizesFromMonitor(self):
        monitor_model = self.monitor_model

        if monitor_model is None:
            # If there is no monitor model selected, then just use a default
            # model so that we at least get some fairly safe resolutions.
            monitor_model = GetMonitorModelDB().getMonitorByName("Monitor 800x600")

        self.mode_list = GetMonitorModeDB().getAvailableModes(monitor_model,self.monitor_aspect)
        resolutions = set()
        for mode in self.mode_list:
            pw = mode.getWidth()
            ph = mode.getHeight()
            if (pw,ph) in self.standard_sizes and pw>=640 and ph>=480:
                resolutions.add( (pw,ph) )

        # Filter the sizes by the amount of video ram that we have.
        color_bytes = self._getColorDepth()/8
        if self.gfx_card.getGfxCardModel().getNeedVideoRam():
            video_memory = self.gfx_card.getVideoRam()
        else:
            video_memory = 65536 # Big enough.
        video_memory *= 1024 # Convert to bytes.

        # Filter the list of modes according to available memory.
        self.available_sizes = [mode for mode in resolutions if mode[0]*mode[1]*color_bytes <= video_memory]

        self.available_sizes.sort()

    def _getColorDepth(self):
        if self.gfx_card.getGfxCardModel().getNeedVideoRam():
            # If this card has limited memory then we fall back to 16bit colour.
            if self.gfx_card.getVideoRam() <= 4096:
                return 16   # 16bit colour
            else:
                return 24   # 24bit colour
        else:
            return 24

    def getName(self):
        try:
            return "Screen %i" % (self.gfx_card.setup.getUsedScreens().index(self)+1)
        except ValueError:
            return "Screen ?"

    def isLive(self):
        """Returns True if this screen is currently being used by the X server.
        """
        return self.x_live_screen is not None

    def getMonitorModel(self):
        """

        Returns a MonitorModel object or None.
        """
        return self.monitor_model

    def setMonitorModel(self,monitor_model):
        """

        Setting the monitor also changes the resolutions that are available. 

        """
        self.monitor_model = monitor_model
        self._resyncResolution()

    def getMonitorAspect(self):
        """
        Get the aspect ratio for the monitor

        Returns one of ModeLine.ASPECT_4_3 or ModeLine.ASPECT_16_9.
        """
        return self.monitor_aspect

    def setMonitorAspect(self,aspect):
        """Specify the aspect ratio of the monitor.

        Keyword arguments:
        aspect -- Aspect ratio. Either the constant ModeLine.ASPECT_4_3 or ModeLine.ASPECT_16_9.

        Setting this also changes the resolutions that are available. 
        """
        self.monitor_aspect = aspect
        self._resyncResolution()

    def _resyncResolution(self):
        try:
            (preferred_width,preferred_height) = self.getAvailableResolutions()[self.getResolutionIndex()]
        except IndexError:
            print self.getAvailableResolutions()
            (preferred_width,preferred_height) = self.getAvailableResolutions()[-1]

        if self.isResolutionLive():
            self._computeSizesFromXorg()
        else:
            # The list of resolutions needs to be updated.
            self._computeSizesFromMonitor()

        if self.gfx_card.setup.getLayout()==XSetup.LAYOUT_CLONE:
            if self.gfx_card.setup.getPrimaryScreen() is self:
                # Filter the list of resolutions based on what the secondary screen can show.
                secondary_screen = self.gfx_card.setup.getSecondaryScreen()
                primary_set = set(self.available_sizes)
                secondary_set = set(secondary_screen.available_sizes)

                common_set = primary_set.intersection(secondary_set)

                suitable_resolutions = []
                # Make sure that each resolution also has a common refresh rate.
                for resolution in common_set:
                    primary_rates = self.getAvailableRefreshRatesForResolution(self.available_sizes.index(resolution))
                    secondary_rates = secondary_screen.getAvailableRefreshRatesForResolution(secondary_screen.available_sizes.index(resolution))

                    if len(set(primary_rates).intersection(set(secondary_rates)))!=0:
                        suitable_resolutions.append(resolution)

                suitable_resolutions.sort()
                self.available_sizes = suitable_resolutions

        # Now we select a resolution that closely matches the previous resolution.
        best_score = 2000000    # big number.
        best_index = 0
        resolution_list = self.getAvailableResolutions()
        for i in range(len(resolution_list)):
            (width,height) = resolution_list[i]
            new_score = abs(width-preferred_width) + abs(height-preferred_height)

            if new_score < best_score:
                best_index = i
                best_score = new_score
        self.setResolutionIndex(best_index)

        if self.gfx_card.setup.getLayout()==XSetup.LAYOUT_CLONE:
            if self.gfx_card.setup.getSecondaryScreen() is self:
                self.gfx_card.setup.getPrimaryScreen()._resyncResolution()

    def isXorgConfigChanged(self):
        isroot = os.getuid()==0
        return self.original_monitor_model is not self.monitor_model \
            or self.original_monitor_aspect != self.monitor_aspect \
            or self.isGammaSettingsChanged() \
            or (self.isResolutionSettingsChanged() and (not self.isResolutionLive() or isroot))

    def getRedGamma(self):
        """Get the current red gamma value.
        """
        return self.redgamma

    def setRedGamma(self,value):
        """Set gamma correction value for red

        This method takes effect immediately on the X server if possible.

        Keyword arguments:
        value -- gamma correction value (float)
        """
        self.redgamma = value
        if self.x_live_screen is not None:
            self.x_live_screen.setGamma( (self.redgamma,self.greengamma,self.bluegamma) )
        self.settingall = False

    def getGreenGamma(self):
        """Get the current green gamma value
        """
        return self.greengamma

    def setGreenGamma(self,value):
        """Set gamma correction value for green

        This method takes effect immediately on the X server if possible.

        Keyword arguments:
        value -- gamma correction value (float)
        """
        self.greengamma = value
        if self.x_live_screen is not None:
            self.x_live_screen.setGamma( (self.redgamma,self.greengamma,self.bluegamma) )
        self.settingall = False

    def getBlueGamma(self):
        """Get the current blue gamma value
        """
        return self.bluegamma

    def setBlueGamma(self,value):
        """Set gamma correction value for blue

        This method takes effect immediately on the X server if possible.

        Keyword arguments:
        value -- gamma correction value (float)
        """
        self.bluegamma = value
        if self.x_live_screen is not None:
            self.x_live_screen.setGamma( (self.redgamma,self.greengamma,self.bluegamma) )
        self.settingall = False

    def getAllGamma(self):
        """Get the gamma correction value for all colours.

        Returns a float.

        See isGammaEqual()
        """
        return self.allgamma

    def setAllGamma(self,value):
        """Set the gamma correction value for all colours.

        Keyword arguments:
        value -- gamma correction value (float)
        """
        self.allgamma = value
        if self.x_live_screen is not None:
            self.x_live_screen.setGamma( (self.allgamma,self.allgamma,self.allgamma) )
        self.settingall = True

    def isGammaLive(self):
        """Returns true if modifications to the gamma are immediately visible.
        """
        return self.x_live_screen is not None

    def isGammaEqual(self):
        """Test whether each colour is using the same gamma correction value.

        Returns True if the gamma value is the same for all colours
        """
        return self.getRedGamma()==self.getGreenGamma()==self.getBlueGamma()

    def getScreenIndex(self):
        return self.gfx_card.getScreens().index(self)

    # Size and resolution
    def getResolutionIndex(self):
        """Get the current resolution of this screen.

        Returns an index into the list of available resolutions. See
        getAvailableResolutions().
        """
        return self.currentsizeindex

    def setResolutionIndex(self,index):
        """Set the resolution for this screen.

        This method does not take effect immediately, only after applyResolutionSetttings()
        has been called.

        Keyword arguments:
        index -- The index of the resolution to use. See getAvailableResolutions().
        """
        self.currentsizeindex = index

    def getAvailableResolutions(self):
        """Get the list of available resolutions.

        Returns a list of screen (width,height) tuples. width and height are in
        pixels.
        """
        return self.available_sizes[:]

    # Rotation
    def getRotation(self):
        """Get the current rotation settings for this screen.

        Returns one of Screen.RR_Rotate_0, Screen.RR_Rotate_90,
        Screen.RR_Rotate_180 or Screen.RR_Rotate_270
        """
        return self.currentrotation

    def setRotation(self,rotation):
        """Set the rotation for this screen

        This method does not take effect immediately, only after
        applyResolutionSetttings() has been called. See getAvailableRotations()
        for how to find out which rotations are supported.

        Keyword arguments:
        rotation -- One of Screen.RR_Rotate_0, Screen.RR_Rotate_90,
                    Screen.RR_Rotate_180 or Screen.RR_Rotate_270
        """
        self.currentrotation = rotation

    def getAvailableRotations(self):
        """Get the supported rotations for this screen.

        Returns a bitmask of support rotations for this screen. The returned
        integer is the bitwise OR of one or more of the constants here below.
        * Screen.RR_Rotate_0
        * Screen.RR_Rotate_90
        * Screen.RR_Rotate_180
        * Screen.RR_Rotate_270
        """
        if self.x_live_screen is not None and self.x_live_screen.resolutionSupportAvailable():
            return self.x_live_screen.getAvailableRotations() & \
                (self.RR_Rotate_0 | self.RR_Rotate_90 | self.RR_Rotate_180 | self.RR_Rotate_270)
        else:
            return self.RR_Rotate_0 # FIXME


    # Reflection
    def getReflection(self):
        """Get the current reflection settings for this screen.

        Returns the reflection settings as a bit string. Use Screen.RR_Reflect_X
        and Screen.RR_Reflect_Y as bitmasks to determine which reflections are
        in use.
        """
        return self.currentreflection

    def setReflection(self,reflection):
        """Set the reflection settings for this screen.

        This method does not take effect immediately, only after
        applyResolutionSetttings() has been called. See getAvailableReflections()
        for how to find out which rotations are supported.

        Keyword arguments:
        reflection -- Bit string (Python integer) of desired reflections.
                      Bitwise OR Screen.RR_Reflect_X and Screen.RR_Reflect_Y
                      to construct the string.
        """
        self.currentreflection = reflection

    def getAvailableReflections(self):
        """Get the supported reflections for this screen.

        Returns a bit string (Python integer) of supported reflections. Use
        Screen.RR_Reflect_X and Screen.RR_Reflect_Y as bitmasks to determine
        which reflections are available.
        """        
        if self.x_live_screen is not None and self.x_live_screen.resolutionSupportAvailable():
            return self.x_live_screen.getAvailableRotations() & (self.RR_Reflect_X | self.RR_Reflect_Y)
        else:
            return 0 # FIXME

    # Refresh rates
    def getRefreshRateIndex(self):
        """Get the current refresh rate index for this screen.

        Returns an index into the list of refresh rates. See getAvailableRefreshRates().
        """
        rates = self.getAvailableRefreshRates()
        i = 0
        for r in rates:
            if r>=self.currentrefreshrate:
                return i
            i += 1
        return len(rates)-1

    def setRefreshRateIndex(self,index):
        """Set the refresh rate for this screen.

        Keyword arguments:
        index -- Index into the list of refresh rates. See getAvailableRefreshRates().
        """
        self.currentrefreshrate = self.getAvailableRefreshRates()[index]

    def getAvailableRefreshRates(self):
        """Get the list of available refresh rates

        Get the list of available refresh rates for the currently selected
        resolution. See setResolutionIndex() and getAvailableRefreshRatesForResolution()

        Returns a list of integers in Hz.
        """
        return self.getAvailableRefreshRatesForResolution(self.currentsizeindex)

    def getAvailableRefreshRatesForResolution(self,resolution_index):
        """Get the list of available refresh rates for the given resolution

        Get the list of available refresh rates for the given resolution.

        Keyword arguments:
        resolution_index -- Index into the list of resolutions.

        Returns a list of integers in Hz.
        """
        isize = self.available_sizes[resolution_index]
        if self.isResolutionLive():
            j = 0
            for size in self.x_live_screen.getAvailableSizes():
                (sw,sh,wm,hm) = size
                if isize==(sw,sh):
                    rates = self.x_live_screen.getAvailableRefreshRates(j)
                    rates.sort()
                    return rates
                j += 1
            assert False,"Can't find matching screen resolution"
        else:
            #
            rates = []
            for mode in self.mode_list:
                if isize==(mode.getWidth(),mode.getHeight()):
                    rates.append(mode.getVRefresh())

            rates.sort()
            return rates

    # Applying changes.

    def isResolutionLive(self):
        return self.x_live_screen is not None and \
                self.x_live_screen.resolutionSupportAvailable() and \
                self.original_monitor_model is self.monitor_model and \
                self.original_monitor_aspect==self.monitor_aspect

    def isResolutionSettingsChanged(self):
        try:
            current_size = self.getAvailableResolutions()[self.currentsizeindex]
        except IndexError:
            #FIXME: why does this happen?
            return False
        return current_size != self.original_size or \
            self.currentrefreshrate != self.originalrefreshrate or \
            self.currentrotation != self.originalrotation or \
            self.currentreflection != self.originalreflection

    def applyResolutionSettings(self):
        """Apply any tending resolution changes on the X server if possible.


        """
        if self.isResolutionSettingsChanged() and self.isResolutionLive():
            # Work out what the correct index is for randr.
            (width,height) = self.available_sizes[self.currentsizeindex]
            sizeindex = 0
            for size in self.x_live_screen.getAvailableSizes():
                (pw,ph,wm,hm) = size
                if pw==width and ph==height:
                    break
                sizeindex += 1  

            rc = self.x_live_screen.setScreenConfigAndRate(sizeindex, \
                self.currentrotation | self.currentreflection, self.currentrefreshrate)

            # FIXME this can fail if the config on the server has been updated.

    def acceptResolutionSettings(self):
        """Accept the last resolution change
        """
        self.originalsizeindex = self.currentsizeindex
        self.original_size = self.getAvailableResolutions()[self.currentsizeindex]
        self.originalrefreshrate = self.currentrefreshrate
        self.originalrotation = self.currentrotation
        self.originalreflection = self.currentreflection

    def revertResolutionSettings(self):
        """Revert the last resolution change on the X server

        """
        if self.x_live_screen is not None and self.x_live_screen.resolutionSupportAvailable():
            # Work out what the correct index is for randr.
            (width,height) = self.available_sizes[self.originalsizeindex]
            sizeindex = 0
            for size in self.x_live_screen.getAvailableSizes():
                (pw,ph,wm,hm) = size
                if pw==width and ph==height:
                    break
                sizeindex += 1  

            self.x_live_screen.setScreenConfigAndRate(sizeindex, \
                self.originalrotation | self.originalreflection, self.originalrefreshrate)
        # FIXME this can fail if the config on the server has been updated.

    def resetResolutionSettings(self):
        """Reset the resolution settings to the last accepted state

        """
        # Restore the resolution settings to their original state.
        self.currentsizeindex = self.originalsizeindex
        self.currentrefreshrate = self.originalrefreshrate
        self.currentrotation = self.originalrotation
        self.currentreflection = self.originalreflection

    def isGammaSettingsChanged(self):
        return self.redgamma != self.originalredgamma or \
            self.greengamma != self.originalgreengamma or \
            self.bluegamma != self.originalbluegamma or \
            self.allgamma != self.originalallgamma or \
            self.settingall != self.originalsettingall

    def acceptGammaSettings(self):
        (self.originalredgamma, self.originalgreengamma, self.originalbluegamma) = (
                                        self.redgamma, self.greengamma, self.bluegamma)
        self.originalallgamma = self.allgamma
        self.originalsettingall = self.settingall

    def revertGammaSettings(self):
        (self.redgamma, self.greengamma, self.bluegamma) = (
                self.originalredgamma, self.originalgreengamma, self.originalbluegamma)
        self.allgamma = self.originalallgamma
        self.settingall = self.originalsettingall

        if self.x_live_screen is not None:
            if self.settingall:
                self.x_live_screen.setGamma( (self.allgamma,self.allgamma,self.allgamma) )
            else:
                self.x_live_screen.setGamma( (self.redgamma,self.greengamma,self.bluegamma) )

    def isGammaSettingsChanged(self):
        if self.settingall:
            return self.originalallgamma != self.allgamma
        else:
            return self.originalredgamma != self.redgamma or \
                self.originalgreengamma != self.greengamma or \
                self.originalbluegamma != self.bluegamma

    def reset(self):
        if self.isLive():
            self.revertGammaSettings()
            self.resetResolutionSettings()

            self.monitor_model = self.original_monitor_model
            self.monitor_aspect = self.original_monitor_aspect

    def getRestartHint(self):
        if self.original_monitor_model is not self.monitor_model \
                or self.original_monitor_aspect != self.monitor_aspect \
                or (self.isResolutionSettingsChanged() and not self.isResolutionLive()):
            return XSetup.RESTART_X
        return XSetup.RESTART_NONE

    def _syncXorgConfig(self,x_device):
        layout = self.gfx_card.getLayout()

        if self.x_config_screen is None:
            self.x_config_screen = self.x_config.makeSection('',['section','screen'])
            self.x_config.append(self.x_config_screen)
            self.x_config_screen.identifier = self.x_config.createUniqueIdentifier("screen")
            self.x_config_screen.device = x_device.identifier

        bit_depth = self.gfx_card.setup._getColorDepth()
        self.x_config_screen.defaultdepth = bit_depth

        # Maybe we don't have a X config monitor section.
        if self.x_config_monitor is None:
            # Make a monitor section.
            self.x_config_monitor = self.x_config.makeSection('',['section','monitor'])
            self.x_config.append(self.x_config_monitor)
            self.x_config_monitor.identifier = self.x_config.createUniqueIdentifier("monitor")
            self.x_config_screen.monitor = self.x_config_monitor.identifier

        # Empty the monitor section and fill it in again.
        monitor_identifier = self.x_config_monitor.identifier
        self.x_config_monitor.clear()
        self.x_config_monitor.identifier = monitor_identifier

        if self.monitor_model is not None:
            if self.monitor_model.getManufacturer() is not None:
                self.x_config_monitor.vendorname = self.monitor_model.getManufacturer()

            self.x_config_monitor.modelname = self.monitor_model.getName()

            if self.monitor_model.getType()!=MonitorModel.TYPE_PLUGNPLAY:
                if self.monitor_model.getHorizontalSync() is not None:
                    hsyncline = self.x_config_monitor.makeLine(None,['HorizSync',self.monitor_model.getHorizontalSync()])
                    self.x_config_monitor.append(hsyncline)

                if self.monitor_model.getVerticalSync() is not None:
                    vsyncline = self.x_config_monitor.makeLine(None,['VertRefresh',self.monitor_model.getVerticalSync()])
                    self.x_config_monitor.append(vsyncline)

            # Add a bunch of standard mode lines.
            mode_list = GetMonitorModeDB().getAvailableModes(self.monitor_model,self.monitor_aspect)

            if mode_list is not None:

                # Filter the mode list by video memory.
                color_bytes = bit_depth/8
                if self.gfx_card.getGfxCardModel().getNeedVideoRam():
                    video_memory = self.gfx_card.getVideoRam()
                else:
                    video_memory = 65536 # Big enough.
                video_memory *= 1024 # Convert to bytes.
                mode_list = [mode for mode in mode_list if mode.getWidth()*mode.getHeight()*color_bytes <= video_memory]

                def mode_cmp(a,b): return cmp(a.getWidth(),b.getWidth())
                mode_list.sort(mode_cmp)

                for mode in mode_list:
                    modeline = self.x_config_monitor.modeline.makeLine(None,mode.getXorgModeLineList())
                    self.x_config_monitor.modeline.append(modeline)

                # Specify the preferred resolution.

                # Get rid of any old display subsections.
                for display_section in self.x_config_screen.getSections('display'):
                    self.x_config_screen.remove(display_section)

                try:
                    (preferred_width, preferred_height) = self.getAvailableResolutions()[self.currentsizeindex]
                    preferred_rate = self.getAvailableRefreshRates()[self.getRefreshRateIndex()]
                except IndexError, errmsg:
                    # This is presumed to be better than a crash:
                    print "Failed to get preferred width, height, or rate - Assuming none. IndexError: ", errmsg
                    preferred_width = 0
                    preferred_height = 0
                    preferred_rate = 0

                # Find the monitor supported mode that best matches what the user has selected.
                best_score = 2000000    # big number.
                best_index = 0
                for i in range(len(mode_list)):
                    mode = mode_list[i]
                    new_score = abs(mode.getWidth()-preferred_width) + \
                                abs(mode.getHeight()-preferred_height) + \
                                abs(mode.getVRefresh()-preferred_rate)
                    if new_score < best_score:
                        best_index = i
                        best_score = new_score

                # This is all about putting the list of resolutions into a 
                # sensible preferred order starting with what the user has chosen
                # and then the rest of the resolutions.
                lower = best_index - 1
                higher = best_index + 1
                len_modes = len(mode_list)

                mode_indexes = []
                mode_indexes.append(best_index)
                while lower>=0 or higher<len_modes:    # interlace the two sets of indexes.
                    if higher<len_modes:
                        mode_indexes.append(higher)
                        higher += 1
                    if lower>=0:
                        mode_indexes.append(lower)
                        lower -= 1

                # Convert the list of resolution indexes into monitor mode names and a modes line for xorg.conf.
                mode_list_line = ['modes']
                mode_list_line.extend([ mode_list[mode_index].getName() for mode_index in mode_indexes ])

                # Create the Display subsections in the Screen section.
                display_section = self.x_config_screen.makeSection(None,['SubSection','Display'])
                display_section.depth = bit_depth

                # The virtual screen size hack should not be used in combination
                # with Xinerama (RandR doesn't work with Xinerama).
                if layout!=XSetup.LAYOUT_SINGLE_XINERAMA and self.isLive():
                    # Find the largest monitor supported mode. We need this info
                    # to set the size of the virtual screen. See the big comment
                    # in displayconfig-restore.py.
                    virtual_width = max([mode_list[mode_index].getWidth() for mode_index in mode_indexes])
                    virtual_height = max([mode_list[mode_index].getHeight() for mode_index in mode_indexes])
                    display_section.append(display_section.makeLine(None,["virtual",virtual_width,virtual_height]))

                display_section.append(display_section.makeLine(None,mode_list_line))

                self.x_config_screen.append(display_section)

        # Set the gamma info too.
        if self.settingall:
            gamma_row = self.x_config_monitor.makeLine(None,['gamma',str(self.allgamma)])
        else:
            gamma_row = self.x_config_monitor.makeLine(None,['gamma',str(self.redgamma),str(self.greengamma),str(self.bluegamma)])
        self.x_config_monitor.append(gamma_row)

        # If resolution changes were not live because the monitor has been changed
        # then we also stop them from being live from now on too.
        if not self.isResolutionLive():
            self.x_live_screen = None
            self.acceptResolutionSettings()

        # The orignal monitor model is now the selected one. => no changes need to be applied now.
        self.original_monitor_model = self.monitor_model
        self.original_monitor_aspect = self.monitor_aspect

    def _getXorgScreenSection(self):
        return self.x_config_screen

    def _getGfxCard(self):
        return self.gfx_card

    def __str__(self):
        # FIXME string = str(self.getIdentifier()) + " {"
        string = " {"
        if self.isLive():
            string += "Size: "
            string += str(self.getAvailableResolutions()[self.getResolutionIndex()])
            string += " "
        else:
            string += "Not live, "
        if self.monitor_model is not None:
            string += "Monitor:" + str(self.monitor_model)
        string += "}"
        return string

############################################################################
class GfxCardModel(object):
    """Describes the properties of a particular model of graphics card.

    """
    def __init__(self,name):
        self.name = name
        self.vendor = None
        self.server = None
        self.driver = None
        self.proprietarydriver = None
        self.lines = []
        self.seeobj = None
        self.noclockprobe = None
        self.unsupported = None
        self.driglx = None
        self.utahglx = None
        self.driglxexperimental = None        
        self.utahglxexperimental = None
        self.badfbrestore = None
        self.badfbrestoreexf3 = None
        self.multihead = None
        self.fbtvout = None
        self.needvideoram = None

    def getName(self): return self.name

    def setVendor(self,vendor): self.vendor = vendor
    def getVendor(self): return self._get(self.vendor,"getVendor",None)
    def setServer(self,server): self.server = server
    def getServer(self): return self._get(self.server,"getServer",None)
    def setDriver(self,driver): self.driver = driver
    def getDriver(self): return self._get(self.driver,"getDriver",None)
    def setProprietaryDriver(self,proprietarydriver): self.proprietarydriver = proprietarydriver
    def getProprietaryDriver(self): return self._get(self.proprietarydriver,"getProprietaryDriver",None)
    def addLine(self,line): self.lines.append(line)
    def getLines(self):
        if (len(self.lines)==0) and (self.seeobj is not None):
            return self.seeobj.getLines()
        else:
            return self.lines[:] # Copy

    def setNoClockProbe(self,noprobe): self.noclockprobe = noprobe
    def getNoClockProbe(self): return self._get(self.noclockprobe,"getNoClockProbe",False)
    def setUnsupported(self,unsupported): self.unsupported = unsupported
    def getUnsupported(self): return self._get(self.unsupported,"getUnsupported",False)
    def setDriGlx(self,on): self.driglx = on
    def getDriGlx(self): return self._get(self.driglx,"getDriGlx",False)
    def setUtahGlx(self,on): self.utahglx = on
    def getUtahGlx(self): return self._get(self.utahglx,"getUtahGlx",False)
    def setDriGlxExperimental(self,on): self.driglxexperimental = on
    def getDriGlxExperimental(self): return self._get(self.driglxexperimental,"getDriGlxExperimental",False)
    def setUtahGlxExperimental(self,on): self.utahglxexperimental = on
    def getUtahGlxExperimental(self): return self._get(self.utahglxexperimental,"getUtahGlxExperimental",False)
    def setBadFbRestore(self,on): self.badfbrestore = on
    def getBadFbRestore(self,proprietary=False):
        if proprietary:
            driver = self.getProprietaryDriver()
        else:
            driver = self.getDriver()
        if driver in ['i810','intel','fbdev','nvidia','vmware']:
            return True
        if self.badfbrestore is not None:
            return self.badfbrestore
        if self.seeobj is not None:
            return self.seeobj.getBadFbRestore(proprietary)
        return False
    def setBadFbRestoreXF3(self,on): self.badfbrestoreexf3 = on
    def getBadFbRestoreXF3(self): return self._get(self.badfbrestoreexf3,"getBadFbRestoreXF3",False)
    def setMultiHead(self,n): self.multihead = n
    def getMultiHead(self): return self._get(self.multihead,"getMultiHead",1)
    def setFbTvOut(self,on): self.fbtvout = on
    def getFbTvOut(self): return self._get(self.fbtvout,"getFbTvOut",False)
    def setNeedVideoRam(self,on): self.needvideoram = on
    def getNeedVideoRam(self): return self._get(self.needvideoram,"getNeedVideoRam",False)
    def setSee(self,seeobj): self.seeobj = seeobj

    # If the seeobj is set, then all attributes that are not filled in for this
    # instance are inheritted from seeobj.
    def _get(self,attr,meth,default):
        if attr is not None:
            return attr
        if self.seeobj is not None:
            return getattr(self.seeobj,meth)()
        else:
            return default

    def __str__(self):
        return self.getName()

############################################################################
gfxcard_model_db_instance = None # Singleton.

def GetGfxCardModelDB():
    """Returns a GfxCardModelDB instance.
    """
    global gfxcard_model_db_instance
    # Lazy instantiation.
    if gfxcard_model_db_instance is None:
        gfxcard_model_db_instance = GfxCardModelDB()
    return gfxcard_model_db_instance

############################################################################
class GfxCardModelDB(object):
    def __init__(self):
        # List of gfx card databases, if order of preference.
        filename = '/usr/share/ldetect-lst/Cards+'
        if not os.path.exists(filename):
            filename = os.path.join(data_file_dir,"Cards+")

        # The card DB. A dict mapping card names to card objects.
        self.db = {}
        # The keys in this dict will be vendor names, values are dicts mapping card names to objects.
        self.vendordb = {} 
        self.driverdb = {}

        self.drivers = self._getAvailableDrivers()

        self.proprietary_drivers = []

        self._checkProprietaryDrivers()
        self._loadDrivers(self.drivers, self.proprietary_drivers)
        self._loadDB(filename)

    def getGfxCardModelByName(self,name):
        return self.db[name]

    def getGfxCardModelByDriverName(self,driver_name):
        return self.driverdb[driver_name]

    def getAllGfxCardModelNames(self):
        return self.db.keys()

    def _getDriverDirs(self):
        "Returns a list of directories where X driver files may be located"

        # Fallback dir:
        defaultDirs = ["/usr/lib/xorg/modules/drivers/"]

        # Get display number:
        display_number = 0
        if "DISPLAY" in os.environ:
            display_name = os.environ["DISPLAY"]
            displayRE = re.compile("^.*:(\d+)\.\d+$")
            m = displayRE.match(display_name)
            if m:
                display_number = int(m.group(1))
            else:
                print "failed to parse display number from '%s' - falling back to default (%d)" % (display_name, display_number)
        else:
            print "$DISPLAY not set - falling back to default number (%d)" % display_number

        # Get the list of module paths from the Xorg log file:
        XLogfile = "/var/log/Xorg.%d.log" % display_number
        cmd = "awk -F \" ModulePath set to \" '/^\(..\) ModulePath set to (.*)/ {print $2}' %s" % XLogfile

        baseList = os.popen(cmd).readline().strip().strip('"')
        if baseList == "":
            print "warning: failed to get module paths from '%s' - falling back to default" % XLogfile
            return defaultDirs

        pathList = []
        for basePath in baseList.split(","):
            pathList.append("%s/drivers/" % basePath)

        return pathList

    def _getAvailableDrivers(self):
        """
        Returns the list of available X graphics drivers.
        Algorithm taken from Xorg source (see GenerateDriverlist() in xf86Config.C).
        """

        # These are drivers that cannot actually be used in xorg.conf, hence they are hidden:
        hiddenDrivers = (
            "atimisc", # seems to be just the internal implementation for ati driver
            "dummy", # dummy driver without any output
            "v4l", # not an actual video device driver, but just the v4l module
            "ztv" # seems to be the TV output module for AMD Geode
        )

        drivers = []
        driverDirectories = self._getDriverDirs()

        driverNameRE = re.compile("^(.+)_drv.(s)?o$")
        for ddir in driverDirectories:
            try:
                driverFiles = os.listdir(ddir)
            except OSError:
                print "error reading directory '%s'" % ddir
                continue
            for f in driverFiles:
                m = driverNameRE.match(f)
                if m:
                    driverName = m.group(1)
                    if driverName in drivers:
                        print "ignoring duplicate driver '%s/%s'" % (ddir, f)
                    else:
                        if driverName in hiddenDrivers:
                            #print "ignoring hidden driver '%s'" % driverName
                            pass
                        else:
                            drivers.append(driverName)
                else:
                    #print "ignoring driver file with invalid name '%s'" % f
                    pass
        #print "found %d drivers" % len(drivers)
        return drivers

    def _checkProprietaryDrivers(self):
        # Check for the NVidia driver.
        # FIXME x86_64 => 'lib64'

        if (os.path.exists("/usr/X11R6/lib/modules/drivers/nvidia_drv.o") and \
                os.path.exists("/usr/X11R6/lib/modules/extensions/libglx.so")) \
                or \
                (os.path.exists("/usr/lib/xorg/modules/drivers/nvidia_drv.o") and \
                os.path.exists("/usr/lib/xorg/modules/libglx.so")) \
                or \
                (os.path.exists("/usr/lib/xorg/modules/drivers/nvidia_drv.so") and \
                os.path.exists("/usr/lib/xorg/modules/extensions/libglx.so")):
            self.proprietary_drivers.append("nvidia")

         # Check for the ATI driver
        if (os.path.exists("/usr/X11R6/lib/modules/dri/fglrx_dri.so") and \
                os.path.exists("/usr/X11R6/lib/modules/drivers/fglrx_drv.o")) or \
                (os.path.exists("/usr/lib/dri/fglrx_dri.so") and \
                os.path.exists("/usr/lib/xorg/modules/drivers/fglrx_drv.so")):
            self.proprietary_drivers.append("fglrx")

        # FIXME MATROX_HAL?

    def _loadDrivers(self, drivers, proprietary_drivers):
        # Insert the Driver entries.
        for drivername in drivers:
            cardobj = GfxCardModel(drivername)
            cardobj.setDriver(drivername)
            self.db[drivername] = cardobj
            self.driverdb[drivername] = cardobj

            if drivername=="nv" and "nvidia" in proprietary_drivers:
                cardobj.setProprietaryDriver("nvidia")
                self.driverdb["nvidia"] = cardobj
            elif drivername=="ati" and "fglrx" in proprietary_drivers:
                cardobj.setProprietaryDriver("fglrx")
                self.driverdb["fglrx"] = cardobj

    def _loadDB(self,filename):
        vendors = ['3Dlabs', 'AOpen', 'ASUS', 'ATI', 'Ark Logic', 'Avance Logic',
            'Cardex', 'Chaintech', 'Chips & Technologies', 'Cirrus Logic', 'Compaq',
            'Creative Labs', 'Dell', 'Diamond', 'Digital', 'ET', 'Elsa', 'Genoa',
            'Guillemot', 'Hercules', 'Intel', 'Leadtek', 'Matrox', 'Miro', 'NVIDIA',
            'NeoMagic', 'Number Nine', 'Oak', 'Orchid', 'RIVA', 'Rendition Verite',
            'S3', 'Silicon Motion', 'STB', 'SiS', 'Sun', 'Toshiba', 'Trident',
            'VideoLogic']

        cardobj = None
        # FIXME the file might be compressed.
        fhandle = open(filename,'r')
        for line in fhandle.readlines():
            line = line.strip()
            if len(line)!=0:
                if not line.startswith("#"):
                    if line.startswith("NAME"):
                        cardobj = GfxCardModel(line[4:].strip())
                        cardname = cardobj.getName()
                        self.db[cardname] = cardobj

                        # Try to extract a vendor name from the card's name.
                        for vendor in vendors:
                            if vendor in cardname:
                                cardobj.setVendor(vendor)
                                if vendor not in self.vendordb:
                                    self.vendordb[vendor] = {}
                                self.vendordb[vendor][cardname] = cardobj
                                break
                        else:
                            if "Other" not in self.vendordb:
                                self.vendordb["Other"] = {}
                            self.vendordb["Other"][cardname] = cardobj

                    elif line.startswith("SERVER"):
                        cardobj.setServer(line[6:].strip())
                    elif line.startswith("DRIVER2"):
                        driver = line[7:].strip()
                        if driver in self.proprietary_drivers:
                            cardobj.setProprietaryDriver(driver)
                    elif line.startswith("DRIVER"):
                        cardobj.setDriver(line[6:].strip())
                    elif line.startswith("LINE"):
                        cardobj.addLine(line[4:].strip())
                    elif line.startswith("SEE"):
                        try:
                            cardobj.setSee(self.db[line[3:].strip()])
                        except KeyError:
                            pass
                    elif line.startswith("NOCLOCKPROBE"):
                        cardobj.setNoClockProbe(True)
                    elif line.startswith("UNSUPPORTED"):
                        cardobj.setUnsupported(True)
                    elif line.startswith("DRI_GLX"):
                        cardobj.setDriGlx(True)
                    elif line.startswith("UTAH_GLX"):
                        cardobj.setUtahGlx(True)
                    elif line.startswith("DRI_GLX_EXPERIMENTAL"):
                        cardobj.setDriGlxExperimental(True)
                    elif line.startswith("UTAH_GLX_EXPERIMENTAL"):
                        cardobj.setUtahGlxExperimental(True)
                    elif line.startswith("BAD_FB_RESTORE"):
                        cardobj.setBadFbRestore(True)
                    elif line.startswith("BAD_FB_RESTORE_XF3"):
                        cardobj.setBadFbRestoreXF3(True)
                    elif line.startswith("MULTI_HEAD"):
                        cardobj.setMultiHead(int(line[10:].strip()))
                    elif line.startswith("FB_TVOUT"):
                        cardobj.setFbTvOut(True)                       
                    elif line.startswith("NEEDVIDEORAM"):
                        cardobj.setNeedVideoRam(True)
        fhandle.close()

############################################################################
class MonitorModel(object):
    TYPE_NORMAL = 0
    TYPE_PLUGNPLAY = 1
    TYPE_CUSTOM = 2

    def __init__(self):
        self.name = None
        self.manufacturer = None
        self.eisaid = None
        self.horizontalsync = None
        self.verticalsync = None
        self.dpms = False
        self.type = MonitorModel.TYPE_NORMAL

    def copy(self):
        newmonitor = MonitorModel()
        newmonitor.name = self.name
        newmonitor.manufacturer = self.manufacturer
        newmonitor.eisaid = self.eisaid
        newmonitor.horizontalsync = self.horizontalsync
        newmonitor.verticalsync = self.verticalsync
        newmonitor.dpms = self.dpms
        return newmonitor

    def getName(self): return self.name
    def setName(self,name): self.name = name
    def getManufacturer(self): return self.manufacturer
    def setManufacturer(self,manufacturer): self.manufacturer = manufacturer
    def setEisaId(self,eisaid): self.eisaid = eisaid
    def getEisaId(self): return self.eisaid    
    def setDpms(self,on): self.dpms = on
    def getDpms(self): return self.dpms
    def getHorizontalSync(self): return self.horizontalsync
    def setHorizontalSync(self,horizontalsync): self.horizontalsync = horizontalsync
    def getVerticalSync(self): return self.verticalsync
    def setVerticalSync(self,verticalsync): self.verticalsync = verticalsync
    def setType(self,flag): self.type = flag
    def getType(self): return self.type
    def __str__(self):
        return "{Name:"+self.name+"}"

############################################################################
class PlugNPlayMonitorModel(MonitorModel):
    def __init__(self,monitor_model_db):
        MonitorModel.__init__(self)
        self.monitor_detected = False
        self.monitor_model_db = monitor_model_db

    def getEisaId(self):
        self._detectMonitor()
        return self.eisaid

    def getHorizontalSync(self):
        self._detectMonitor()
        return self.horizontalsync

    def getVerticalSync(self):
        self._detectMonitor()
        return self.verticalsync

    def _detectMonitor(self):
        if not self.monitor_detected:
            (eisaid, horizontalsync, verticalsync) = self.monitor_model_db._detectMonitor()
            if eisaid is not None:
                self.eisaid = eisaid
            if horizontalsync is not None:
                self.horizontalsync = horizontalsync
            if verticalsync is not None:
                self.verticalsync = verticalsync

            self.monitor_detected = True

############################################################################
monitor_model_db_instance = None # Singleton

def GetMonitorModelDB(force=False):
    """Returns a GetMonitorModelDB instance.
    """
    global monitor_model_db_instance
    if monitor_model_db_instance is None or force == True:
        monitor_model_db_instance = MonitorModelDB()
    return monitor_model_db_instance

############################################################################
class MonitorModelDB(object):
    def __init__(self):
        self.db = {}
        self.vendordb = {}
        self.genericdb = {}
        self.customdb = {}
        self.custom_counter = 1
        self.monitor_detect_run = False

        # Plug'n Play is a kind of fake entry for monitors that are detected but unknown.
        # It's frequency info is filled in by hardware detection or from the X server config.
        self._plugnplay = PlugNPlayMonitorModel(self)
        self._plugnplay.setName("Plug 'n' Play")
        self._plugnplay.setManufacturer(self._plugnplay.getName())
        self._plugnplay.setType(MonitorModel.TYPE_PLUGNPLAY)
        # This default is what Xorg claims to use when there is no
        # horizontal sync info in the a monitor section.
        self._plugnplay.setHorizontalSync("28.0-33.0")
        # This default is what Xorg claims to use when there is no
        # vertical sync info in the a monitor section.
        self._plugnplay.setVerticalSync("43-72")
        self.customdb[self._plugnplay.getName()] = self._plugnplay
        self.db[self._plugnplay.getName()] = self._plugnplay

        # Load monitors from the shipped database
        filename = "/usr/share/ldetect-lst/MonitorsDB"
        if not os.path.exists(filename):
            filename = os.path.join(data_file_dir,"MonitorsDB")
        self.load(filename)
        # Load monitors from the custom database
        filename = os.path.join(var_data_dir, "CustomMonitorsDB")
        if os.path.exists(filename):
            self.load(filename)

    def load(self,filename,split=";"):
        fhandle = open(filename,'r')
        for line in fhandle.readlines():
            line = line.strip()
            if len(line)!=0:
                if not line.startswith("#"):
                    try:
                        parts = line.split(split)
                        monitorobj = MonitorModel()
                        monitorobj.setManufacturer(parts[0].strip())
                        monitorobj.setName(parts[1].strip())
                        monitorobj.setEisaId(parts[2].strip().upper())
                        monitorobj.setHorizontalSync(parts[3].strip())
                        monitorobj.setVerticalSync(parts[4].strip())
                        if len(parts)>=6:
                            monitorobj.setDpms(parts[5].strip()=='1')
                        self.db[monitorobj.getName()] = monitorobj

                        if monitorobj.getManufacturer() in \
                                ["Generic LCD Display", "Generic CRT Display"]:
                            self.genericdb[monitorobj.getName()] = monitorobj
                        else:
                            if monitorobj.getManufacturer() not in self.vendordb:
                                self.vendordb[monitorobj.getManufacturer()] = {}
                            self.vendordb[monitorobj.getManufacturer()]\
                                                [monitorobj.getName()] = monitorobj

                    except IndexError:
                        print "Bad monitor line:",line
        fhandle.close()

    def getMonitorByName(self,name):
        return self.db.get(name,None)

    def newCustomMonitor(self,name=None):
        custom_model = MonitorModel()
        if name is None:
            name = "Custom %i" % self.custom_counter
        custom_model.setName(name)
        self.db[custom_model.getName()] = custom_model        
        self.customdb[name] = custom_model
        self.custom_counter += 1
        return custom_model

    def getCustomMonitors(self):
        return self.customdb

    def detect(self):
        """Detect the attached monitor.

        Returns a 'monitor' object on success, else None.
        """
        (eisaid,hrange,vrange) = self._detectMonitor()

        # Look up the EISAID in our database.
        if eisaid is not None:
            for monitor in self.db:
                if eisaid==self.db[monitor].getEisaId():
                    return self.db[monitor]

        return self._plugnplay

    def _detectMonitor(self):
        if not self.monitor_detect_run:
            eisaid = None
            hrange = None
            vrange = None

            if os.path.isfile("/usr/sbin/monitor-edid"):
                # This utility appeared in Mandriva 2005 LE
                output = ExecWithCapture("/usr/sbin/monitor-edid",["monitor-edid","-v"])
                for line in output.split("\n"):
                    if "HorizSync" in line:
                        hrange = line.split()[1]
                    elif "VertRefresh" in line:
                        vrange = line.split()[1]
                    elif line.startswith("EISA ID:"):
                        eisaid = line[9:].upper()

            elif os.path.isfile("/usr/sbin/ddcxinfos"):
                # This utility _was_ standard on Mandrake 10.1 and earlier.
                output = ExecWithCapture("/usr/sbin/ddcxinfos",["ddcxinfos"])
                for line in output.split("\n"):
                    if "HorizSync" in line:
                        hrange = line.split()[0]
                    elif "VertRefresh" in line:
                        vrange = line.split()[0]
                    elif "EISA ID=" in line:
                        eisaid = line[line.find("EISA ID=")+8:].upper()

            elif os.path.isfile("/usr/sbin/ddcprobe"):
                # on Debian
                """
                ddcprobe's output looks like this:

                ...
                eisa: SAM00b1
                ...
                monitorrange: 30-81, 56-75
                ...
                """
                output = ExecWithCapture("/usr/sbin/ddcprobe",["ddcprobe"])
                for line in output.split("\n"):
                    if line.startswith("eisa:"):
                        parts = line.split(":")
                        if len(parts)>=2:
                            eisaid = parts[1].strip().upper()
                    elif line.startswith("monitorrange:"):
                        parts = line.replace(',','').split()
                        if len(parts)==3:
                            hrange = parts[1].strip()
                            vrange = parts[2].strip()

            self.detected_eisa_id = eisaid
            self.detected_h_range = hrange
            self.detected_v_range = vrange
            self.monitor_detect_run = True

        return (self.detected_eisa_id, self.detected_h_range, self.detected_v_range)

############################################################################

SYNC_TOLERANCE = 0.01    # 1 percent 
class ModeLine(object):
    ASPECT_4_3 = 0
    ASPECT_16_9 = 1

    XF86CONF_PHSYNC = 0x0001
    XF86CONF_NHSYNC = 0x0002
    XF86CONF_PVSYNC = 0x0004
    XF86CONF_NVSYNC = 0x0008
    XF86CONF_INTERLACE = 0x0010
    XF86CONF_DBLSCAN = 0x0020
    XF86CONF_CSYNC = 0x0040
    XF86CONF_PCSYNC = 0x0080
    XF86CONF_NCSYNC = 0x0100
    XF86CONF_HSKEW = 0x0200     # hskew provided 
    XF86CONF_BCAST = 0x0400
    XF86CONF_CUSTOM = 0x0800    # timing numbers customized by editor
    XF86CONF_VSCAN = 0x1000
    flags = {"interlace": XF86CONF_INTERLACE,
        "doublescan": XF86CONF_DBLSCAN,
        "+hsync": XF86CONF_PHSYNC,
        "-hsync": XF86CONF_NHSYNC,
        "+vsync": XF86CONF_PVSYNC,
        "-vsync": XF86CONF_NVSYNC,
        "composite": XF86CONF_CSYNC,
        "+csync": XF86CONF_PCSYNC,
        "-csync": XF86CONF_NCSYNC }

    # Thanks go out to Redhat for this code donation. =)
    def __init__(self, elements):
        self.name = elements[1].strip('"')
        self.clock = float(elements[2])
        self.hdisp = int(elements[3])
        self.hsyncstart = int(elements[4])
        self.hsyncend = int(elements[5])
        self.htotal = int(elements[6])
        self.vdisp = int(elements[7])
        self.vsyncstart = int(elements[8])
        self.vsyncend = int(elements[9])
        self.vtotal = int(elements[10])

        self.flags = 0
        for i in range(11, len(elements)):
            try:
                self.flags |= ModeLine.flags[string.lower(elements[i])]
            except KeyError:
                pass

    def getWidth(self):
        return self.hdisp

    def getHeight(self):
        return self.vdisp

    def getName(self):
        return self.name

    def getVRefresh(self):
        vrefresh = self.clock * 1000000.0 / float(self.htotal * self.vtotal)
        if self.flags & ModeLine.XF86CONF_INTERLACE:
            vrefresh = vrefresh * 2.0
        if self.flags & ModeLine.XF86CONF_DBLSCAN:
            vrefresh = vrefresh / 2.0
        return int(round(vrefresh))

    # Basically copied from xf86CheckModeForMonitor
    def supports(self, monitor_hsync, monitor_vsync):
        hsync = self.clock * 1000 / self.htotal
        for freq in monitor_hsync:
            if hsync > freq[0] * (1.0 - SYNC_TOLERANCE) and hsync < freq[1] * (1.0 + SYNC_TOLERANCE):
                break
        else:
            return False

        vrefresh = self.getVRefresh()
        for freq in monitor_vsync:
            if vrefresh > freq[0] * (1.0 - SYNC_TOLERANCE) and vrefresh < freq[1] * (1.0 + SYNC_TOLERANCE):
                return True
        return False

    def getXorgModeLineList(self):
        row = [self.name, str(self.clock), str(self.hdisp), str(self.hsyncstart), str(self.hsyncend),
                str(self.htotal), str(self.vdisp), str(self.vsyncstart), str(self.vsyncend), str(self.vtotal)]

        for (flag_name,flag_bit) in ModeLine.flags.iteritems():
            if self.flags & flag_bit:
                row.append(flag_name)
        return row

    def __str__(self):
        return "ModeLine:"+self.name

############################################################################
monitor_mode_db_instance = None # Singleton


def GetMonitorModeDB():
    """Returns a GetMonitorModeDB instance.
    """
    global monitor_mode_db_instance
    if monitor_mode_db_instance is None:
        monitor_mode_db_instance = MonitorModeDB()
    return monitor_mode_db_instance

############################################################################
class MonitorModeDB(object):    
    def __init__(self):
        self.db = {}
        self.db169 = {}

        module_dir = os.path.dirname(os.path.join(os.getcwd(),__file__))
        self.load(os.path.join(data_file_dir,"vesamodes"))
        self.load(os.path.join(data_file_dir,"extramodes"))
        self.load(os.path.join(data_file_dir,"widescreenmodes"))

        # Make a list of screen sizes for the getAllResolutions() method.
        self.all_resolutions = []
        for mode in self.db.values()+self.db169.values():
            size = (mode.getWidth(),mode.getHeight())
            if size not in self.all_resolutions:
                self.all_resolutions.append(size)

        self.all_resolutions.sort()

    def load(self,filename):
        fd = open(filename, 'r')
        lines = fd.readlines()
        fd.close()

        for line in lines:
            if line[0] != "#" and line[0] != '/':
                line = line.strip()
                elements = line.split()
                if line!="":
                    if len(elements) < 11 or string.lower(elements[0]) != "modeline":
                        print "Bad modeline found:",line
                        continue
                    name = elements[1][1:-1]
                    new_mode = ModeLine(elements)

                    width = new_mode.getWidth()
                    height = new_mode.getHeight()
                    if self.aspectRatio(width, height)==ModeLine.ASPECT_4_3:
                        self.db[name] = new_mode
                    else:
                        self.db169[name] = new_mode

                    if (width,height)==FALLBACK_RESOLUTION:
                        # We grab these modes and use them a fallbacks in the widescreen list.
                        self.db169[name] = new_mode

    @staticmethod
    def aspectRatio(width,height):
        ratio = float(width)/float(height)
        # 4/3 is 1.333333
        # 16/9 is 1.777777
        # We will just consider anything below 1.45 to be standard.
        if ratio < 1.45:
            return ModeLine.ASPECT_4_3
        else:
            return ModeLine.ASPECT_16_9

    def getAvailableModes(self,monitor,aspect):
        """
        Get the list of video modes that this monitor supports.

        Returns a list of modeline objects or None if the available modes for this monitor are unknown.
        """
        if monitor.horizontalsync is None or monitor.verticalsync is None:
            return None

        result = []

        hsync_list = self._list_from_string(monitor.getHorizontalSync())
        vsync_list = self._list_from_string(monitor.getVerticalSync())

        if aspect==ModeLine.ASPECT_4_3:
            db = self.db
        else:
            db = self.db169

        for modeline in db.values():
            if modeline.supports(hsync_list, vsync_list):
                result.append(modeline)
        return result

    def getAllResolutions(self):
        return self.all_resolutions

    def _list_from_string(self,src):
        l = []
        pieces = src.split(",")
        for piece in pieces:
            tmp = string.split(piece, "-")
            if len(tmp) == 1:
                l.append( (float(tmp[0].strip()), float(tmp[0].strip())) )
            else:
                l.append( (float(tmp[0].strip()), float(tmp[1].strip())) )
        return l

############################################################################

def ranges_to_string(array, length):
    stringobj = ""
    for i in range(length):
        r = array[i]
        if stringobj != "":
            stringobj = stringobj + ","
        if r[0] == r[1]:
            stringobj = stringobj + repr(r[0])
        else:
            stringobj = stringobj + repr(r[0]) + "-"  + repr(r[1])
    return stringobj


def main():
    # FIXME: turns this into a real set of unit tests.
    SetDataFileDir("ldetect-lst")

    #xs = XSetup()
    #xs = XSetup('xorg.conf.test')
    xs = XSetup(xorg_config_filename='bug_data/tonio_intel/xorg.conf',
            debug_scan_pci_filename="bug_data/tonio_intel/PCIbus.txt")
    print str(xs)
    return

    #screen1 = xs.getGfxCards()[0].getScreens()[0]
    #monitor_db = GetMonitorModelDB()
    #new_model = monitor_db.getMonitorByName('Samsung SyncMaster 15GL')
    #print new_model
    #screen1.setMonitorModel(new_model)

    #screen2 = xs.getGfxCards()[0].getScreens()[1]
    #screen2.setMonitorModel(new_model)

    print "getAvailableLayouts(): ",xs.getAvailableLayouts()
    xs.getGfxCards()[0].setProprietaryDriver(True)
    print str(xs)
    xs.setLayout(XSetup.LAYOUT_CLONE) # XSetup.LAYOUT_DUAL.
    print "getAvailableLayouts(): ",xs.getAvailableLayouts()
    print str(xs)

    #gfxcard_db = GetGfxCardModelDB()
    #new_gfxcard_model = gfxcard_db.getGfxCardModelByName('NVIDIA GeForce FX (generic)')
    ##'ATI Radeon 8500'
    ##'NVIDIA GeForce FX (generic)'
    #print new_gfxcard_model
    #gfx_card = xs.getGfxCards()[0]
    #gfx_card.setProprietaryDriver(False)
    #gfx_card.setGfxCardModel(new_gfxcard_model)
    xs.writeXorgConfig('xorg.conf.test')

if __name__=='__main__':
    main()