path: root/displayconfig/displayconfig.py

#!/usr/bin/python
# -*- coding: UTF-8 -*-
###########################################################################
# displayconfig.py - description                                          #
# ------------------------------                                          #
# begin     : Fri Mar 26 2004                                             #
# copyright : (C) 2004-2006 by Simon Edwards                              #
# email     : [email protected]                                         #
#                                                                         #
###########################################################################
#                                                                         #
#   This program is free software; you can redistribute it and/or modify  #
#   it under the terms of the GNU General Public License as published by  #
#   the Free Software Foundation; either version 2 of the License, or     #
#   (at your option) any later version.                                   #
#                                                                         #
###########################################################################

from qt import *
from tdecore import *
from tdeui import *
import xorgconfig
import xf86misc
import string
import os
import select
import sys
import csv
import time
import signal
import shutil
from ktimerdialog import *
from displayconfigwidgets import *
from displayconfigabstraction import *
from execwithcapture import *

programname = "Display and Graphics Configuration"
version = "0.8.0"
DUAL_PREVIEW_SIZE = 240

# Are we running as a separate standalone application or in KControl?
standalone = __name__=='__main__'

# Running as the root user or not?
isroot = os.getuid()==0

############################################################################
class GfxCardDialog(KDialogBase):
    video_ram_list = [256,512,1024,2048,4096,8192,16384,32768,65536]

    def __init__(self,parent):
        KDialogBase.__init__(self,parent,None,True,"Choose Graphics Card", 
                            KDialogBase.Ok|KDialogBase.Cancel, KDialogBase.Cancel)

        self.gfxcarddb = None
        self.updatingGUI = True
        self.card2listitem = {}

        topbox = QVBox(self)
        topbox.setSpacing(KDialog.spacingHint())
        self.setMainWidget(topbox)
        label = QLabel(topbox)
        label.setText(i18n("Select Graphics Card:"))
        self.listview = KListView(topbox)
        self.listview.addColumn("")
        self.listview.header().hide()
        self.listview.setRootIsDecorated(True)
        self.connect(self.listview,SIGNAL("selectionChanged(QListViewItem *)"),self.slotListClicked)
        topbox.setStretchFactor(self.listview,1)

        self.driver = KListViewItem(self.listview)
        self.driver.setText(0,i18n("Drivers"))
        self.driver.setSelectable(False)

        self.manufacturer = KListViewItem(self.listview)
        self.manufacturer.setText(0,i18n("Manufacturers"))
        self.manufacturer.setSelectable(False)

        hbox = QHBox(topbox)
        topbox.setStretchFactor(hbox,0)
        vbox = QVBox(hbox)

        self.detected_label = QLabel("",vbox)

        self.detected_button = KPushButton(vbox)
        self.detected_button.setText(i18n("Select"))
        self.connect(self.detected_button,SIGNAL("clicked()"),self.slotSelectDetectedClicked)

        spacer = QWidget(vbox)
        vbox.setStretchFactor(self.detected_button,0)
        vbox.setStretchFactor(spacer,1)

        hbox.setStretchFactor(vbox,0)
        spacer = QWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        drivergrid = QGrid(2,hbox)
        drivergrid.setSpacing(KDialog.spacingHint())
        QLabel(i18n("Driver:"),drivergrid)
        self.standarddriverradio = QRadioButton(i18n("Standard"),drivergrid)
        self.connect(self.standarddriverradio,SIGNAL("clicked()"),self.slotStandardDriverClicked)
        QWidget(drivergrid)
        self.proprietarydriverradio = QRadioButton(i18n("Proprietary"),drivergrid)
        self.connect(self.proprietarydriverradio,SIGNAL("clicked()"),self.slotProprietaryDriverClicked)

        QLabel(i18n("Video RAM:"),drivergrid)
        self.videoramcombo = QComboBox(drivergrid)
        for s in [i18n("256 kB"),
                i18n("512 kB"),
                i18n("1 MB"),
                i18n("2 MB"),
                i18n("4 MB"),
                i18n("8 MB"),
                i18n("16 MB"),
                i18n("32 MB"),
                i18n("64 MB or more")]:
            self.videoramcombo.insertItem(s)    

        self.updatingGUI = False
        self._setGfxCardDB(GetGfxCardModelDB())

    def _setGfxCardDB(self,gfxcarddb):
        self.updatingGUI = True
        self.gfxcarddb = gfxcarddb

        # Add the GfxCards under the Manufacturer item.
        keys = gfxcarddb.vendordb.keys()
        keys.sort()
        for key in keys:
            cardkeys = self.gfxcarddb.vendordb[key].keys()
            vendoritem = KListViewItem(self.manufacturer)
            vendoritem.setText(0,key)
            vendoritem.setSelectable(False)
            for cardkey in cardkeys:
                item = KListViewItem(vendoritem)
                item.setText(0,cardkey)
                self.card2listitem[self.gfxcarddb.vendordb[key][cardkey]] = item

        # Add the GfxCard _drivers_ under the Drivers item
        drivers = gfxcarddb.driverdb.keys()
        drivers.sort()
        for driver in drivers:
            driveritem = KListViewItem(self.driver)
            driveritem.setText(0,driver)
            self.card2listitem[gfxcarddb.driverdb[driver]] = driveritem

        self.updatingGUI = False

    def do(self,card,proprietarydriver,detected_card,video_ram):
        self.updatingGUI = True
        item = self.card2listitem[card]
        self.listview.setSelected(item,True)
        self.listview.ensureItemVisible(item)

        self.selected_video_ram = video_ram

        if detected_card is None:
            self.detected_button.setEnabled(False)
            self.detected_label.setText(i18n("Detected graphics card:\n(unknown)"))
        else:
            self.detected_button.setEnabled(True)
            self.detected_label.setText(i18n("Detected graphics card:\n'%1'.").arg(detected_card.getName()))

        self.__syncDriver(card,proprietarydriver,video_ram)

        self.detected_card = detected_card
        self.selected_card = card
        self.updatingGUI = False

        if self.exec_loop()==QDialog.Accepted:
            return (self.selected_card,
                self.proprietarydriverradio.isChecked() and (self.selected_card is not None),
                self.video_ram_list[self.videoramcombo.currentItem()])
        else:
            return (card, proprietarydriver,video_ram)

    def __syncDriver(self,card,proprietarydriver,videoram):
        if card.getProprietaryDriver() is None:
            self.standarddriverradio.setChecked(True)
            self.standarddriverradio.setEnabled(False)
            self.proprietarydriverradio.setEnabled(False)
        else:
            self.standarddriverradio.setEnabled(True)
            self.proprietarydriverradio.setEnabled(True)
            self.standarddriverradio.setChecked(not proprietarydriver)
            self.proprietarydriverradio.setChecked(proprietarydriver)

        self.videoramcombo.setEnabled(card.getNeedVideoRam())
        if card.getNeedVideoRam():
            self.videoramcombo.setCurrentItem(self.video_ram_list.index(videoram))

    def slotSelectDetectedClicked(self):
        self.updatingGUI = True
        item = self.card2listitem[self.detected_card]
        self.listview.setSelected(item,True)
        self.listview.ensureItemVisible(item)
        self.selected_card = self.detected_card
        self.__syncDriver(self.selected_card, self.proprietarydriverradio.isChecked(), self.selected_video_ram)
        self.updatingGUI = False

    def slotListClicked(self,item):
        if self.updatingGUI:
            return

        for key in self.card2listitem:
            value = self.card2listitem[key]
            if value is item:
                self.selected_card = key
                self.__syncDriver(self.selected_card, self.proprietarydriverradio.isChecked(), self.selected_video_ram)

    def slotStandardDriverClicked(self):
            self.proprietarydriverradio.setChecked(False)
            self.standarddriverradio.setChecked(True)

    def slotProprietaryDriverClicked(self):
            self.standarddriverradio.setChecked(False)
            self.proprietarydriverradio.setChecked(True)

############################################################################
class MonitorDialog(KDialogBase):
    def __init__(self,parent):
        KDialogBase.__init__(self,parent,None,True,"Choose Monitor", 
            KDialogBase.Ok|KDialogBase.Cancel, KDialogBase.Cancel)

        self.monitordb = None
        self.selectedmonitor = None
        self.aspect = ModeLine.ASPECT_4_3
        self.monitor2listitem = {}
        self.updatingGUI = True

        topbox = QVBox(self)
        topbox.setSpacing(KDialog.spacingHint())
        self.setMainWidget(topbox)
        label = QLabel(topbox)
        label.setText(i18n("Select Monitor:"))
        self.listview = KListView(topbox)
        self.listview.addColumn("")
        self.listview.header().hide()
        self.listview.setRootIsDecorated(True)
        self.connect(self.listview,SIGNAL("selectionChanged(QListViewItem *)"),self.slotListClicked)

        self.generic = KListViewItem(self.listview)
        self.generic.setText(0,i18n("Generic"))
        self.generic.setSelectable(False)

        self.manufacturer = KListViewItem(self.listview)
        self.manufacturer.setText(0,i18n("Manufacturers"))
        self.manufacturer.setSelectable(False)

        grid = QGroupBox(4,QGroupBox.Horizontal,topbox)
        grid.setTitle(i18n("Details"))

        label = QLabel(grid)
        label.setText(i18n("Horizontal Range:"))

        self.horizrange = KLineEdit(grid)
        self.horizrange.setReadOnly(True)

        label = QLabel(grid)
        label.setText(i18n("Vertical Refresh:"))

        self.vertrange = KLineEdit(grid)
        self.vertrange.setReadOnly(True)

        hbox = QHBox(topbox)

        self.detectbutton = KPushButton(hbox)
        self.detectbutton.setText(i18n("Detect Monitor")) # FIXME better label/text?
        self.connect(self.detectbutton,SIGNAL("clicked()"),self.slotDetectClicked)

        spacer = QWidget(hbox)
        hbox.setStretchFactor(self.detectbutton,0)
        hbox.setStretchFactor(spacer,1)

        label = QLabel(hbox)
        label.setText(i18n("Image format:"))
        hbox.setStretchFactor(label,0)

        self.aspectcombobox = KComboBox(hbox)
        self.aspectcombobox.insertItem(i18n("Standard 4:3"))
        self.aspectcombobox.insertItem(i18n("Widescreen 16:9"))
        hbox.setStretchFactor(self.aspectcombobox,0)

        self.updatingGUI = False

    def setMonitorDB(self,monitordb):
        self.monitordb = monitordb

        # Add the Monitors
        vendors = monitordb.vendordb.keys()
        vendors.sort()
        for vendor in vendors:
            monitorkeys = self.monitordb.vendordb[vendor].keys()
            vendoritem = KListViewItem(self.manufacturer)
            vendoritem.setText(0,vendor)
            vendoritem.setSelectable(False)
            for monitorkey in monitorkeys:
                item = KListViewItem(vendoritem)
                item.setText(0,monitorkey)
                self.monitor2listitem[self.monitordb.vendordb[vendor][monitorkey]] = item

        generics = monitordb.genericdb.keys()
        generics.sort()
        for generic in generics:
            genericitem = KListViewItem(self.generic)
            genericitem.setText(0,generic)
            self.monitor2listitem[monitordb.genericdb[generic]] = genericitem

        customs = monitordb.getCustomMonitors().keys()
        customs.sort()
        for custom in customs:
            customitem = KListViewItem(self.listview)
            customitem.setText(0,custom)
            self.monitor2listitem[monitordb.getCustomMonitors()[custom]] = customitem

    def do(self,monitor,aspect,is_primary_monitor=True):
        """Run the monitor selection dialog.

        Parameters:

        monitor - Currently selected 'Monitor' object.

        Returns the newly selected monitor object and aspect ratio as a tuple.
        """
        if monitor is not None:
            self.selectedmonitor = monitor
            item = self.monitor2listitem[monitor]

            self.listview.setSelected(item,True)
            self.listview.ensureItemVisible(item)

        else:
            self.selectedmonitor = None
            self.listview.clearSelection()
        self.aspect = aspect

        # Only the first/primary monitor can be detected. :-/
        self.detectbutton.setEnabled(is_primary_monitor)

        self.updatingGUI = True
        self._syncGUI()
        self.updatingGUI = False

        if self.exec_loop()!=QDialog.Accepted:
            # Dialog was cancelled. Return the original monitor.
            self.selectedmonitor = monitor
        else:
            self.aspect = [ModeLine.ASPECT_4_3,ModeLine.ASPECT_16_9][self.aspectcombobox.currentItem()]

        return (self.selectedmonitor,self.aspect)

    def slotDetectClicked(self):
        detectedmonitor = self.monitordb.detect()
        if detectedmonitor is not None:
            self.selectedmonitor = detectedmonitor
            self._syncGUI()
        else:
            KMessageBox.error(self, i18n("Sorry, the model and capabilities of your\nmonitor couldn't be detected."),
                i18n("Monitor detection failed"))

    def slotListClicked(self,item):
        if self.updatingGUI:
            return
        self.updatingGUI = True
        for key in self.monitor2listitem:
            value = self.monitor2listitem[key]
            if value is item:
                self.selectedmonitor = key
                break
        self._syncGUI()
        self.updatingGUI = False

    def _syncGUI(self):
        if self.selectedmonitor is not None:
            item = self.monitor2listitem[self.selectedmonitor]
            self.listview.setSelected(item,True)
            self.listview.ensureItemVisible(item)
            self.vertrange.setText(self.selectedmonitor.getVerticalSync())
            self.horizrange.setText(self.selectedmonitor.getHorizontalSync())
        else:
            self.vertrange.setText("-")
            self.horizrange.setText("-")

        self.aspectcombobox.setCurrentItem({ModeLine.ASPECT_4_3:0,ModeLine.ASPECT_16_9:1}[self.aspect])

############################################################################
if standalone:
    programbase = KDialogBase
else:
    programbase = KCModule

############################################################################
class DisplayApp(programbase):
    ########################################################################
    def __init__(self,parent=None,name=None):
        global standalone,isroot,kapp
        KGlobal.locale().insertCatalogue("guidance")

        if standalone:
            KDialogBase.__init__(self,KJanusWidget.Tabbed,"Display Configuration",\
                KDialogBase.Apply|KDialogBase.User1|KDialogBase.User2|KDialogBase.Close, KDialogBase.Close)
            self.setButtonText(KDialogBase.User1,i18n("Reset"))
            self.setButtonText(KDialogBase.User2,i18n("About"))
        else:
            KCModule.__init__(self,parent,name)
            self.setButtons(KCModule.Apply|KCModule.Reset)
            self.aboutdata = MakeAboutData()

            # This line has the effect of hiding the "Admin only" message and also forcing
            # the Apply/Reset buttons to be shown. Yippie! Only had to read the source
            # to work that out.
            self.setUseRootOnlyMsg(False) 

        # Create a configuration object.
        self.config = KConfig("displayconfigrc")

        # Compact mode means that we have to make the GUI 
        # much smaller to fit on low resolution screens.
        self.compact_mode = kapp.desktop().height()<=600

        KGlobal.iconLoader().addAppDir("guidance")

        global imagedir
        imagedir = unicode(KGlobal.dirs().findDirs("data","guidance/pics/displayconfig")[0])

        self.imagedir = imagedir

        self.xconfigchanged = False
        self.xconfigtested = True

        self.availabletargetgammas = [unicode(i18n('1.4')),unicode(i18n('1.6')),unicode(i18n('1.8')),unicode(i18n('2.0')),unicode(i18n('2.2')),unicode(i18n('2.4'))]
        self.lightimages = []
        self.mediumimages = []
        self.darkimages = []

        # X Server stuff
        self.xf86server = xf86misc.XF86Server()

        self.xconfigpath = self._findXorgConfig()
        SetDataFileDir(unicode(KGlobal.dirs().findResourceDir("data","guidance/pcitable")) + "guidance/")
        self.xsetup = XSetup(self.xconfigpath)

        self.updatingGUI = True
        self.gfxcarddb = GfxCardModelDB()
        self.monitordb = GetMonitorModelDB()
        self.monitormodedb = GetMonitorModeDB()

        self._buildGUI()

        # Work out if the currently running Gfxdriver is safe enough that we
        # can test other drivers at the same time.
        self.badfbrestore = self._badFbRestore()
        self.testbutton.setEnabled(isroot and not self._badFbRestore())
        if isroot and not self._badFbRestore():
            self.testunavailablelabel.hide()
        else:
            self.testunavailablelabel.show()

        # Load up some of our databases, and initialise our state variables.
        if len(self.xsetup.getUsedScreens()):
            self.currentsizescreen = self.xsetup.getUsedScreens()[0]
            self.currentgammascreen = self.xsetup.getUsedScreens()[0]
        else:
            # FIXME
            print "Houston, we have a problem: No screens found in configuration file, exiting. :("
            sys.exit(1)

        self.monitordialog.setMonitorDB(self.monitordb)

        self.aboutus = KAboutApplication(self)

        # For centering the timed Apply dialog.
        self.applytimerdialog = None
        self.connect(kapp.desktop(), SIGNAL("resized(int)"), self.slotDesktopResized)
        self.applydialogscreenindex = 0

        self.__loadImages()
        self._loadConfig()
        self._syncGUI()

        if standalone:
            self.enableButton(KDialogBase.User1,False) # Reset button
            self.enableButtonApply(False) # Apply button

        self.updatingGUI = False

    def _findXorgConfig(self):
        # Lookup location of X configfile
        for line in ExecWithCapture("xset", ["xset","q"],True).split('\n'):
            if line.strip().startswith("Config file"):
                return line.split(":")[1].strip()
        # Sometimes, xset doesn't know about the configfile location, hence ...
        if os.path.isfile("/etc/X11/xorg.conf"):
                return "/etc/X11/xorg.conf"
        return None

    def _buildGUI(self):
        global standalone
        if not standalone:
            toplayout = QVBoxLayout( self, 0, KDialog.spacingHint() )
            tabcontrol = QTabWidget(self)
            toplayout.addWidget(tabcontrol)
            toplayout.setStretchFactor(tabcontrol,1)

        #--- Size, Orientation and Positioning ---
        tabname = i18n("Size, Orientation && Positioning")
        if standalone:
            sopage = self.addGridPage(1,QGrid.Horizontal,tabname)
            sopage.setSpacing(0)
            self.SizePage = SizeOrientationPage(sopage,self.xsetup,self.compact_mode)
        else:
            self.SizePage = SizeOrientationPage(tabcontrol,self.xsetup,self.compact_mode)
            self.SizePage.setMargin(KDialog.marginHint())

        # Connect all PYSIGNALs from SizeOrientationPage Widget to appropriate actions.
        self.connect(self.SizePage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
        self.connect(self.SizePage,PYSIGNAL("resolutionChange(int)"),self.slotResolutionChange)

        if not standalone:
            tabcontrol.addTab(self.SizePage,tabname)

        #--- Color & Gamma tab ---
        tabname = i18n("Color && Gamma")
        if standalone:
            gammapage = self.addVBoxPage(tabname)
            vbox = QVBox(gammapage)
        else:
            vbox = QVBox(tabcontrol)
            vbox.setMargin(KDialog.marginHint())
        vbox.setSpacing(KDialog.spacingHint())

        hbox = QHBox(vbox)
        hbox.setSpacing(KDialog.spacingHint())
        vbox.setStretchFactor(hbox,0)
        label = QLabel(hbox,"textLabel1")
        label.setText(i18n("Screen:"))
        hbox.setStretchFactor(label,0)
        self.gammadisplaycombobox = QComboBox(0,hbox,"comboBox11")
        hbox.setStretchFactor(self.gammadisplaycombobox,0)
        spacer = QWidget(hbox)
        hbox.setStretchFactor(spacer,1)
        self.connect(self.gammadisplaycombobox,SIGNAL("activated(int)"),self.slotGammaScreenCombobox)

        # fill the combobox.
        for screen in self.xsetup.getUsedScreens():
            self.gammadisplaycombobox.insertItem(screen.getName())

        if not self.compact_mode:
            # Create the colour matching pics
            label = QLabel(vbox)
            label.setText(i18n("Color calibration image:"))
            vbox.setStretchFactor(label,0)

            hbox = QWidget(vbox)
            hboxlayout = QHBoxLayout(hbox)
            hboxlayout.setSpacing(KDialog.spacingHint())
            self.mediumpic = QLabel(hbox)
            self.mediumpic.setFixedSize(305,105)
            hboxlayout.addWidget(self.mediumpic,0,Qt.AlignTop)

            label = QLabel(hbox)
            label.setPixmap(SmallIcon('info'))
            hboxlayout.addWidget(label,0,Qt.AlignTop)

            label = QLabel(i18n("<qt><p>Gamma controls how your monitor displays colors.</p><p>For accurate color reproduction, adjust the gamma correction sliders until the squares blend into the background as much as possible.</p></qt>"),hbox)
            label.setTextFormat(Qt.RichText)
            hboxlayout.addWidget(label,1,Qt.AlignTop)

        sliderspace = QWidget(vbox)

        grid = QGridLayout(sliderspace, 9, 4, 0, KDialog.spacingHint())
        grid.setSpacing(KDialog.spacingHint())
        grid.setColStretch(0,0)
        grid.setColStretch(1,0)
        grid.setColStretch(2,0)
        grid.setColStretch(3,1)

        label = QLabel(i18n("Gamma correction:"),sliderspace)
        grid.addWidget(label, 0, 0)

        self.gammaradiogroup = QButtonGroup()
        self.gammaradiogroup.setRadioButtonExclusive(True)
        self.connect(self.gammaradiogroup,SIGNAL("clicked(int)"),self.slotGammaRadioClicked)

        self.allradio = QRadioButton(sliderspace)
        grid.addWidget(self.allradio, 0, 1, Qt.AlignTop)

        label = QLabel(i18n("All:"),sliderspace)
        grid.addWidget(label, 0, 2)

        self.gammaslider = KDoubleNumInput(0.4, 3.5, 2.0, 0.05, 2, sliderspace, 'gammaslider')
        grid.addMultiCellWidget(self.gammaslider,0,1,3,3)
        self.gammaslider.setRange(0.5, 2.5, 0.05, True)
        self.connect(self.gammaslider, SIGNAL("valueChanged(double)"), self.slotGammaChanged)

        self.componentradio = QRadioButton(sliderspace)
        grid.addWidget(self.componentradio, 2, 1, Qt.AlignTop)

        label = QLabel(i18n("Red:"),sliderspace)
        grid.addWidget(label, 2, 2)

        self.redslider = KDoubleNumInput(self.gammaslider,0.4, 3.5, 2.0, 0.05, 2, sliderspace, 'redslider')
        grid.addMultiCellWidget(self.redslider,2,3,3,3)
        self.redslider.setRange(0.5, 2.5, 0.05, True)
        self.connect(self.redslider, SIGNAL("valueChanged(double)"), self.slotRedChanged)

        label = QLabel(i18n("Green:"),sliderspace)
        grid.addWidget(label, 4, 2)

        self.greenslider = KDoubleNumInput(self.redslider,0.4, 3.5, 2.0, 0.05, 2, sliderspace, 'greenslider')
        grid.addMultiCellWidget(self.greenslider,4,5,3,3)
        self.greenslider.setRange(0.5, 2.5, 0.05, True)
        self.connect(self.greenslider, SIGNAL("valueChanged(double)"), self.slotGreenChanged)

        label = QLabel(i18n("Blue:"),sliderspace)
        grid.addWidget(label, 6, 2)

        self.blueslider = KDoubleNumInput(self.greenslider,0.4, 3.5, 2.0, 0.05, 2, sliderspace, 'blueslider')
        grid.addMultiCellWidget(self.blueslider,6,7,3,3)
        self.blueslider.setRange(0.5, 2.5, 0.05, True)
        self.connect(self.blueslider, SIGNAL("valueChanged(double)"), self.slotBlueChanged)

        self.gammaradiogroup.insert(self.allradio,0)
        self.gammaradiogroup.insert(self.componentradio,1)

        if not self.compact_mode:
            label = QLabel(i18n("Target gamma:"),sliderspace)
            grid.addWidget(label, 8, 0)

            hbox = QHBox(sliderspace)
            self.targetgammacombo = KComboBox(False,hbox)
            self.targetgammacombo.insertItem(i18n('1.4'))
            self.targetgammacombo.insertItem(i18n('1.6'))
            self.targetgammacombo.insertItem(i18n('1.8 Apple Macintosh standard'))
            self.targetgammacombo.insertItem(i18n('2.0 Recommend'))
            self.targetgammacombo.insertItem(i18n('2.2 PC standard, sRGB'))
            self.targetgammacombo.insertItem(i18n('2.4'))
            hbox.setStretchFactor(self.targetgammacombo,0)
            spacer = QWidget(hbox)
            hbox.setStretchFactor(spacer,1)
            grid.addMultiCellWidget(hbox, 8, 8, 1, 3)

            self.connect(self.targetgammacombo,SIGNAL("activated(int)"),self.slotTargetGammaChanged)

        spacer = QWidget(vbox)
        vbox.setStretchFactor(spacer,1)

        if not standalone:
            tabcontrol.addTab(vbox,tabname)

        #--- Hardware tab ---
        if standalone:
            hardwarepage = self.addVBoxPage(i18n("Hardware"))
            vbox = QVBox(hardwarepage)
        else:
            vbox = QVBox(tabcontrol)
            vbox.setMargin(KDialog.marginHint())
        self.gfxcarddialog = GfxCardDialog(None)
        self.monitordialog = MonitorDialog(None)

        self.xscreenwidgets = []

        for gfxcard in self.xsetup.getGfxCards():
            w = GfxCardWidget(vbox,self.xsetup, gfxcard, self.gfxcarddialog, self.monitordialog)
            self.xscreenwidgets.append(w)
            self.connect(w,PYSIGNAL("configChanged"),self.slotConfigChanged)

        spacer = QWidget(vbox)
        vbox.setStretchFactor(spacer,1)

        if not self.xsetup.mayModifyXorgConfig():
            QLabel(i18n("Changes on this tab require 'root' access."),vbox)
            if not standalone:
                QLabel(i18n("Click the \"Administrator Mode\" button to allow modifications on this tab."),vbox)

        hbox = QHBox(vbox)
        hbox.setSpacing(KDialog.spacingHint())
        self.testbutton = KPushButton(i18n("Test"),hbox)
        self.connect(self.testbutton,SIGNAL("clicked()"),self.slotTestClicked)
        hbox.setStretchFactor(self.testbutton,0)

        self.testunavailablelabel = QHBox(hbox)
        self.testunavailablelabel.setSpacing(KDialog.spacingHint())
        tmplabel = QLabel(self.testunavailablelabel)
        self.testunavailablelabel.setStretchFactor(tmplabel,0)
        tmplabel.setPixmap(SmallIcon('info'))
        label = QLabel(i18n("This configuration cannot be safely tested."),self.testunavailablelabel)
        self.testunavailablelabel.setStretchFactor(label,1)
        self.testunavailablelabel.hide()

        spacer = QWidget(hbox)
        hbox.setStretchFactor(spacer,1)
        vbox.setStretchFactor(hbox,0)

        if not standalone:
            tabcontrol.addTab(vbox,i18n("Hardware"))

        #--- Display Power Saving ---
        tabname = i18n("Power saving")
        if standalone:
            powerpage = self.addGridPage(1,QGrid.Horizontal,tabname)
            self.dpmspage = DpmsPage(powerpage)
        else:
            self.dpmspage = DpmsPage(tabcontrol)
            self.dpmspage.setMargin(KDialog.marginHint())

        #self.SizePage.setScreens(self.xsetup.getScreens())

        # Connect all PYSIGNALs from SizeOrientationPage Widget to appropriate actions.
        #self.connect(self.SizePage,PYSIGNAL("dualheadEnabled(bool)"),self.slotDualheadEnabled)
        self.connect(self.dpmspage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)

        if not standalone:
            tabcontrol.addTab(self.dpmspage,tabname)

    def save(self): # KCModule
        xorg_config_changed = self.xsetup.isXorgConfigChanged()
        restart_recommended = self.xsetup.getRestartHint()

        # Check the Size & Orientation tab.
        if self.applytimerdialog is None:
            self.applytimerdialog = KTimerDialog(15000, KTimerDialog.CountDown, self, "mainKTimerDialog",
                True, i18n("Confirm Display Setting Change"), KTimerDialog.Ok | KTimerDialog.Cancel, \
                KTimerDialog.Cancel)
            self.applytimerdialog.setButtonOK(KGuiItem(i18n("&Keep"), "button_ok"))
            self.applytimerdialog.setButtonCancel(KGuiItem(i18n("&Cancel"), "button_cancel"))
            label = KActiveLabel(i18n("Trying new screen settings. Keep these new settings? (Automatically cancelling in 15 seconds.)"),
                self.applytimerdialog, "userSpecifiedLabel")
            self.applytimerdialog.setMainWidget(label)

        if self.xsetup.isLiveResolutionConfigChanged():
            if self.xsetup.applyLiveResolutionChanges():
                # running X server config has changed. Ask the user.
                KDialog.centerOnScreen(self.applytimerdialog, 0)
                if self.applytimerdialog.exec_loop():
                    self.xsetup.acceptLiveResolutionChanges()
                else:
                    try:
                        self.xsetup.rejectLiveResolutionChanges()
                    except:
                        """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
                        print "Live gamma change not supported"
                    return
            else:
                # Nothing really changed, just accept the changes.
                self.xsetup.acceptLiveResolutionChanges()


        self.xsetup.acceptLiveGammaChanges()
        self.dpmspage.apply()

        # Save the X server config.
        if isroot and xorg_config_changed:

            if not self.xconfigtested:
                if self.badfbrestore or self._badFbRestore():
                    if KMessageBox.warningContinueCancel(self, \
                            i18n("The selected driver and monitor configuration can not be safely tested on this computer.\nContinue with this configuration?"),
                            i18n("Configuration not tested"))!=KMessageBox.Continue:
                        return
                else:
                    if KMessageBox.warningContinueCancel(self,
                            i18n("The selected driver and monitor configuration has not been successfully tested on this computer.\nContinue with this configuration?"),
                            i18n("Configuration not tested"))!=KMessageBox.Continue:
                        return

            try:
                # Backup up the current config file.
                i = 1
                while os.path.exists("%s.%i" % (self.xconfigpath,i)):
                    i += 1
                try:
                    shutil.copyfile(self.xconfigpath,"%s.%i" % (self.xconfigpath,i))
                except IOError, errmsg:
                    print "IOError", errmsg, " - while trying to save new xorg.conf - trying to fix"
                    self.xconfigpath = "/etc/X11/xorg.conf"
                    xorgfile = open(self.xconfigpath, 'a')
                    xorgfile.close()
                    shutil.copyfile(self.xconfigpath,"%s.%i" % (self.xconfigpath,i))

                # Write out the new config
                tmpfilename = self.xconfigpath + ".tmp"
                self.xsetup.writeXorgConfig(tmpfilename)

                os.rename(tmpfilename,self.xconfigpath)
            except (IOError,TypeError):
                print "******* Bang"
                raise
                return
                # FIXME error

            # FIXME the instructions in these messages are probably not quite right.
            if restart_recommended==XSetup.RESTART_X:
                KMessageBox.information(self,
                    i18n("Some changes require that the X server be restarted before they take effect. Log out and select \"Restart X server\" from the menu button."),
                    i18n("X Server restart recommend"))

            if restart_recommended==XSetup.RESTART_SYSTEM:
                KMessageBox.information(self,
                    i18n("Some changes require that the entire system be restarted before they take effect. Log out and select \"Restart computer\" from the log in screen."),
                    i18n("System restart recommend"))

        self._saveConfig()
        self._sendChangedSignal()

    # Called when the desktop is resized. Just center the confirm dialog.
    def slotDesktopResized(self):
        if self.applytimerdialog is not None:
            KDialog.centerOnScreen(self.applytimerdialog, self.applydialogscreenindex)

    def slotApply(self): # KDialogBase
        self.save()

    def slotClose(self): # KDialogBase
        try:
            self.xsetup.rejectLiveGammaChanges()
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
        KDialogBase.slotClose(self)

    def load(self): # KCModule
        self.__reset()
        self._sendChangedSignal()

    def slotUser1(self): # Reset button, KDialogBase
        self.load()

    def slotUser2(self): # About button, KDialogBase
        self.aboutus.show()

    def slotResolutionChange(self,i):
        self.currentsizescreen.setResolutionIndex(i)
        self._sendChangedSignal()

    def slotTargetGammaChanged(self,i):
        self.targetgamma = i
        self._selectGamma(self.targetgamma)
        self._sendChangedSignal()

    def slotGammaRadioClicked(self,i):
        self.settingall = i==0
        self.gammaslider.setDisabled(not self.settingall)
        self.redslider.setDisabled(self.settingall)
        self.greenslider.setDisabled(self.settingall)
        self.blueslider.setDisabled(self.settingall)
        try:
            if self.settingall:
                self.currentgammascreen.setAllGamma(self.currentgammascreen.getAllGamma())
            else:
                self.currentgammascreen.setRedGamma(self.currentgammascreen.getRedGamma())
                self.currentgammascreen.setGreenGamma(self.currentgammascreen.getGreenGamma())
                self.currentgammascreen.setBlueGamma(self.currentgammascreen.getBlueGamma())
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
	self._sendChangedSignal()

    def slotGammaChanged(self,value):
        if self.updatingGUI:
            return
        try:
            self.currentgammascreen.setAllGamma(value)
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
        self._sendChangedSignal()

    def slotRedChanged(self,value):
        if self.updatingGUI:
            return
        try:
            self.currentgammascreen.setRedGamma(value)
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
        self._sendChangedSignal()

    def slotGreenChanged(self,value):
        if self.updatingGUI:
            return
        try:
            self.currentgammascreen.setGreenGamma(value)
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
        self._sendChangedSignal()

    def slotBlueChanged(self,value):
        if self.updatingGUI:
            return
        try:
            self.currentgammascreen.setBlueGamma(value)
        except:
            """Workaround! FIXME: Use isGammaLive function in displayconfigabstraction when this is implemented"""
            print "Live gamma change not supported"
        self._sendChangedSignal()

    def slotGammaScreenCombobox(self,i):
        self.currentgammascreen = self.xsetup.getUsedScreens()[i]
        self._syncGUI()
        self._sendChangedSignal()

    def slotConfigChanged(self):
        self.xconfigchanged = True
        self.xconfigtested = False

        # Check if the current X config can be tested.
        self.SizePage._syncGUI()
        for widget in self.xscreenwidgets:
            widget.syncConfig()
        self._syncTestButton()
        self._sendChangedSignal()

    def slotTestClicked(self):
        self.xconfigtested = self.testX()

    def testX(self):

        self.xserverbin = "/usr/X11R6/bin/XFree86"
        if not os.path.isfile(self.xserverbin):
            self.xserverbin = "/usr/X11R6/bin/Xorg"
        rc = False

        # Remove an stale X server lock
        try: os.remove("/tmp/.X9-lock")
        except OSError: pass

        # Try to find a safe tmp dir.
        tmp_dir = None
        if os.environ.get("TMPDIR") is not None:
            tmp_dir = os.environ.get("TMPDIR")
        if tmp_dir is None or not os.path.isdir(tmp_dir):
            tmp_dir = os.path.join(os.environ.get("HOME"),"tmp")
            if not os.path.isdir(tmp_dir):
                tmp_dir = "/tmp"
        working_tmp_dir = os.path.join(tmp_dir,"guidance."+str(os.getpid()))
        error_filename = os.path.join(working_tmp_dir,"testserver.xoutput")
        config_filename = os.path.join(working_tmp_dir,"testserver.config")
        auth_filename = os.path.join(working_tmp_dir,"xauthority")

        # Start the Xserver up with the new config file.
        try:
            # Create our private dir.
            os.mkdir(working_tmp_dir,0700)

            # Backup the XAUTHORITY environment variable.
            old_xauthority = os.environ.get("XAUTHORITY",None)

            # Write out the new config file.
            self.xsetup.writeXorgConfig(config_filename)

            os.system("xauth -f %s add :9 . `mcookie`" % (auth_filename,) )
            # FIXME:: -xf86config is nowhere in man X ??
            pid = os.spawnv(os.P_NOWAIT,"/bin/bash",\
                ["bash","-c","exec %s :9 -xf86config %s -auth %s &> %s" % \
                    (self.xserverbin, config_filename, auth_filename, error_filename)])
            print "Got pid",pid

            # Wait for the server to show up.
            print str(os.waitpid(pid,os.WNOHANG))

            # Use our private xauthority file.
            os.environ["XAUTHORITY"] = auth_filename

            time.sleep(1) # Wait a sec.
            testserver = None
            while True:
                # Try connecting to the server.
                try:
                    testserver = xf86misc.XF86Server(":9")
                    break
                except xf86misc.XF86Error:
                    testserver = None
                # Check if the server process is still alive.
                if os.waitpid(pid,os.WNOHANG) != (0,0):
                    break
                time.sleep(1) # Give the server some more time.

            print "checkpoint 1"
            print str(testserver)

            if testserver is not None:
                # Start the timed popup on the :9 display.
                #servertestpy = str(KGlobal.dirs().findResource("data","guidance/servertestdialog.py"))
                servertestpy = os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])),"servertestdialog.py")
                pythonexe = unicode(KStandardDirs.findExe("python"))

                testrc = os.system(pythonexe + " " + servertestpy + " '" + auth_filename+"' ")
                rc = (rc >> 8) == 0 # Test is good if the return code was 0.
                testserver = None
                os.kill(pid,signal.SIGINT)
            else:
                # Server failed, read the error info.
                msg = ""
                try:
                    fhandle = open(error_filename,'r')
                    for line in fhandle.readlines():
                        if (line.startswith("(EE)") and ("Disabling" not in line)) or line.startswith("Fatal"):
                            msg += line
                    msg = unicode(i18n("Messages from the X server:\n")) + msg
                except IOError:
                    msg += unicode(i18n("Sorry, unable to capture the error messages from the X server."))
                KMessageBox.detailedSorry(self,i18n("Sorry, this configuration video card driver\nand monitor doesn't appear to work."),msg)

        finally:
            # Attempt some cleanup before we go.
            try: os.remove(error_filename)
            except OSError: pass
            try: os.remove(config_filename)
            except OSError: pass
            try: os.remove(auth_filename)
            except OSError: pass
            try: os.rmdir(working_tmp_dir)
            except OSError: pass

            if old_xauthority is None:
                del os.environ["XAUTHORITY"]
            else:
                os.environ["XAUTHORITY"] = old_xauthority

        return rc

    def _syncGUI(self):
        self.SizePage._syncGUI()

        for gfxcard_widget in self.xscreenwidgets:
            gfxcard_widget.syncConfig()

        # Sync the gamma tab.
        if not self.compact_mode:
            self.targetgammacombo.setCurrentItem(self.targetgamma)
            self._selectGamma(self.targetgamma)

        if self.currentgammascreen.isGammaEqual():
            self.gammaradiogroup.setButton(0)
        else:
            self.gammaradiogroup.setButton(1)
        
        self.gammaslider.setValue(self.currentgammascreen.getAllGamma())
        self.redslider.setValue(self.currentgammascreen.getRedGamma())
        self.greenslider.setValue(self.currentgammascreen.getGreenGamma())
        self.blueslider.setValue(self.currentgammascreen.getBlueGamma())

        self.settingall = self.currentgammascreen.isGammaEqual()
        self.gammaslider.setDisabled(not self.settingall)
        self.redslider.setDisabled(self.settingall)
        self.greenslider.setDisabled(self.settingall)
        self.blueslider.setDisabled(self.settingall)
        self._syncTestButton()

    def _syncTestButton(self):
        currentbadfbrestore = self._badFbRestore()
        self.testbutton.setEnabled(self.xsetup.mayModifyXorgConfig() and not (self.badfbrestore or currentbadfbrestore))
        if not isroot or (self.xsetup.mayModifyXorgConfig() and not (self.badfbrestore or currentbadfbrestore)):
            self.testunavailablelabel.hide()
        else:
            self.testunavailablelabel.show()

    def _loadConfig(self):
        self.config.setGroup("General")
        t = self.config.readEntry("targetgamma",unicode(i18n("2.0")))
        if t in self.availabletargetgammas:
            t = unicode(i18n('2.0'))
        self.targetgamma = self.availabletargetgammas.index(t)

    def _saveConfig(self):
        global isroot
        if isroot:
            return
        self.config.setGroup("General")
        self.config.writeEntry("targetgamma",self.availabletargetgammas[self.targetgamma])
        for s in self.xsetup.getUsedScreens():
            self.config.setGroup("Screen"+str(s.getScreenIndex()))
            self._saveRandRConfig(s)
            
            # Write out the gamma values.
            if self.settingall:
                self.config.writeEntry("redgamma", str(s.getAllGamma()))
                self.config.writeEntry("greengamma", str(s.getAllGamma()))
                self.config.writeEntry("bluegamma", str(s.getAllGamma()))
            else:
                self.config.writeEntry("redgamma", str(s.getRedGamma()))
                self.config.writeEntry("greengamma", str(s.getGreenGamma()))
                self.config.writeEntry("bluegamma", str(s.getBlueGamma()))
            
        self.config.writeEntry("dpmsSeconds", self.dpmspage.seconds)
        self.config.writeEntry("dpmsEnabled", ("off","on")[self.dpmspage.enabled])
        self.config.sync()

    def _saveRandRConfig(self,screen):
        w,h = screen.getAvailableResolutions()[screen.getResolutionIndex()]
        self.config.writeEntry("width",w)
        self.config.writeEntry("height",h)
        self.config.writeEntry("reflectX", int( (screen.getReflection() & screen.RR_Reflect_X)!=0) )
        self.config.writeEntry("reflectY", int((screen.getReflection() & screen.RR_Reflect_Y)!=0) )
        self.config.writeEntry("refresh", screen.getAvailableRefreshRates()[screen.getRefreshRateIndex()])
        rotationmap = {screen.RR_Rotate_0: "0", screen.RR_Rotate_90: "90",
                        screen.RR_Rotate_180:"180", screen.RR_Rotate_270: "270"}
        self.config.writeEntry("rotate", rotationmap[screen.getRotation()])

    def _selectGamma(self,i):
        self.mediumpic.setPixmap(self.mediumimages[i])

    def __loadImages(self):
        if not self.compact_mode:
            for g in ['14','16','18','20','22','24']:
                self.mediumimages.append( QPixmap(self.imagedir+'gammapics/MGam'+g+'.png') )

        self.previewscreen = QPixmap(self.imagedir+'monitor_screen_1280x1024.png')
        self.previewscreenportrait = QPixmap(self.imagedir+'monitor_screen_1024x1280.png')

    def __reset(self):
        # Reset the screen settings.
        self.xsetup.reset()
        self.dpmspage.reset()
        self._syncGUI()

    # Kcontrol expects updates about whether the contents have changed.
    # Also we fake the Apply and Reset buttons here when running outside kcontrol.
    def _sendChangedSignal(self):
        global standalone

        changed = False
        for s in self.xsetup.getUsedScreens():
            changed = changed or s.isResolutionSettingsChanged()

        changed = changed or self.xsetup.isXorgConfigChanged()
        changed = changed or self.dpmspage.isChanged()

        if standalone:
            self.enableButton(KDialogBase.User1,changed) # Reset button
            self.enableButtonApply(changed) # Apply button
        else:
            self.emit(SIGNAL("changed(bool)"), (changed,) )

    def _badFbRestore(self):
        bad_fb_restore = False
        for card in self.xsetup.getGfxCards():
            bad_fb_restore = bad_fb_restore or \
                ((card.getGfxCardModel() is not None) and card.getGfxCardModel().getBadFbRestore(card.isProprietaryDriver()))
        return bad_fb_restore

############################################################################
class SizeOrientationPage(QWidget):
    """
    A TabPage with all the settings for Size and Orientation of the screens,
    also features Refreshrates and Dualheadsettings.

    Emits the following signals:

        changeSignal()

        ...

        TODO:
            * Update __doc__ with emitted signals, connect these.
            * Choose screen (more than one preview)
            * Relative positioning.
            * Call setRefreshCombo after switching screens.
    """
    def __init__(self,parent,xsetup,compact):
        QWidget.__init__(self,parent)

        global imagedir
        self.xsetup = xsetup
        self.imagedir = imagedir
        self.parent = parent
        self.current_screen = self.xsetup.getPrimaryScreen()
        self.current_is_primary = True
        self.compact_mode = compact

        self._buildGUI()
        self._syncGUI()

    def _syncGUI(self):
        if self.current_is_primary:
            self.current_screen = self.xsetup.getPrimaryScreen()
        else:
            self.current_screen = self.xsetup.getSecondaryScreen()

        self._syncGUILayout()
        self._syncGUIScreen()

    def _syncGUILayout(self):
        # Secondary monitor radios.
        available_layouts = self.xsetup.getAvailableLayouts()

        may = self.xsetup.mayModifyLayout()

        self.secondary_clone_radio.setEnabled(may and available_layouts & self.xsetup.LAYOUT_CLONE)
        self.secondary_clone_radio.setShown(available_layouts & self.xsetup.LAYOUT_CLONE)

        self.secondary_dual_radio.setEnabled(may and available_layouts & self.xsetup.LAYOUT_DUAL)
        self.secondary_dual_radio.setShown(available_layouts & self.xsetup.LAYOUT_DUAL)

        self.secondary_position_combo.setEnabled(may and self.xsetup.getLayout()==self.xsetup.LAYOUT_DUAL)
        self.secondary_position_combo.setShown(available_layouts & self.xsetup.LAYOUT_DUAL)

        self.secondary_groupbox.setEnabled(may and available_layouts != self.xsetup.LAYOUT_SINGLE)
        # If only the single layout is available, then we just hide the whole radio group
        self.secondary_groupbox.setShown(available_layouts!=self.xsetup.LAYOUT_SINGLE)

        if self.xsetup.getLayout()!=self.xsetup.LAYOUT_SINGLE:
            self.secondary_radios.setButton(self.secondary_option_ids[self.xsetup.getLayout()])
        else:
            if available_layouts & XSetup.LAYOUT_CLONE:
                self.secondary_radios.setButton(self.secondary_option_ids[XSetup.LAYOUT_CLONE])
            else:
                self.secondary_radios.setButton(self.secondary_option_ids[XSetup.LAYOUT_DUAL])

        self.secondary_groupbox.setChecked(self.xsetup.getLayout() != self.xsetup.LAYOUT_SINGLE)

    def _syncGUIScreen(self):
        # Sync the size tab.
        self.resize_slider.setScreen(self.current_screen)

        if self.xsetup.getLayout()!=self.xsetup.LAYOUT_DUAL:
            self.resize_slider.setTitle(i18n("Screen size"))
        else:
            self.resize_slider.setTitle(i18n("Screen size #%1").arg(self.xsetup.getUsedScreens().index(self.current_screen)+1))

        if self.xsetup.getLayout()==self.xsetup.LAYOUT_DUAL:
            if not self.compact_mode:
                self.monitor_preview_stack.raiseWidget(self.dual_monitor_preview)
        else:
            if not self.compact_mode:
                self.monitor_preview_stack.raiseWidget(self.monitor_preview)

        # Sync the screen orientation.
        width,height = self.current_screen.getAvailableResolutions()[self.current_screen.getResolutionIndex()]

        if not self.compact_mode:
            self.monitor_preview.setResolution(width,height)

            if self.current_screen.getRotation()==Screen.RR_Rotate_0:
                self.monitor_preview.setRotation(MonitorPreview.ROTATE_0)
            elif self.current_screen.getRotation()==Screen.RR_Rotate_90:
                self.monitor_preview.setRotation(MonitorPreview.ROTATE_90)
            elif self.current_screen.getRotation()==Screen.RR_Rotate_270:
                self.monitor_preview.setRotation(MonitorPreview.ROTATE_270)
            else:
                self.monitor_preview.setRotation(MonitorPreview.ROTATE_180)

            self.monitor_preview.setReflectX(self.current_screen.getReflection() & Screen.RR_Reflect_X)
            self.monitor_preview.setReflectY(self.current_screen.getReflection() & Screen.RR_Reflect_Y)

            # Set the resolutions for the dual screen preview.
            if self.xsetup.getAvailableLayouts() & XSetup.LAYOUT_DUAL:
                for i in [0,1]:
                    screen = [self.xsetup.getPrimaryScreen(), self.xsetup.getSecondaryScreen()][i]
                    width,height = screen.getAvailableResolutions()[screen.getResolutionIndex()]
                    self.dual_monitor_preview.setScreenResolution(i,width,height)
            self.dual_monitor_preview.setPosition(self.xsetup.getDualheadOrientation())

        self._fillRefreshCombo()

        self.orientation_radio_group.setButton( \
            [Screen.RR_Rotate_0, Screen.RR_Rotate_90, Screen.RR_Rotate_270, 
                Screen.RR_Rotate_180].index(self.current_screen.getRotation()))
        # This construct above just maps an rotation to a radiobutton index.
        self.mirror_horizontal_checkbox.setChecked(self.current_screen.getReflection() & Screen.RR_Reflect_X)
        self.mirror_vertical_checkbox.setChecked(self.current_screen.getReflection() & Screen.RR_Reflect_Y)

        width,height = self.current_screen.getAvailableResolutions()[self.current_screen.getResolutionIndex()]
        if not self.compact_mode:
            self.monitor_preview.setResolution(width,height)

        # Enable/disable the resolution/rotation/reflection widgets.
        may_edit = self.xsetup.mayModifyResolution()
        self.normal_orientation_radio.setEnabled(may_edit)
        available_rotations = self.current_screen.getAvailableRotations()

        # Hide the whole group box if there is only one boring option.
        self.orientation_group_box.setShown(available_rotations!=Screen.RR_Rotate_0)

        self.left_orientation_radio.setEnabled(available_rotations & Screen.RR_Rotate_90 and may_edit)
        self.left_orientation_radio.setShown(available_rotations & Screen.RR_Rotate_90)

        self.right_orientation_radio.setEnabled(available_rotations & Screen.RR_Rotate_270 and may_edit)
        self.right_orientation_radio.setShown(available_rotations & Screen.RR_Rotate_270)

        self.upside_orientation_radio.setEnabled(available_rotations & Screen.RR_Rotate_180 and may_edit)
        self.upside_orientation_radio.setShown(available_rotations & Screen.RR_Rotate_180)

        self.mirror_horizontal_checkbox.setEnabled(available_rotations & Screen.RR_Reflect_X and may_edit)
        self.mirror_horizontal_checkbox.setShown(available_rotations & Screen.RR_Reflect_X)

        self.mirror_vertical_checkbox.setEnabled(available_rotations & Screen.RR_Reflect_Y and may_edit)
        self.mirror_vertical_checkbox.setShown(available_rotations & Screen.RR_Reflect_Y)

        self.resize_slider.setEnabled(may_edit)
        self.size_refresh_combo.setEnabled(may_edit)

        # Set the dual orientation combo.
        self.secondary_position_combo.setCurrentItem(
            [XSetup.POSITION_LEFTOF,
            XSetup.POSITION_RIGHTOF,
            XSetup.POSITION_ABOVE,
            XSetup.POSITION_BELOW].index(self.xsetup.getDualheadOrientation()))

    def _fillRefreshCombo(self):
        # Update refresh combobox
        self.size_refresh_combo.clear()
        for rate in self.current_screen.getAvailableRefreshRates():
            self.size_refresh_combo.insertItem(i18n("%1 Hz").arg(rate))
        self.size_refresh_combo.setCurrentItem(self.current_screen.getRefreshRateIndex())
        self.current_screen.setRefreshRateIndex(self.size_refresh_combo.currentItem())

    def slotMonitorFocussed(self,currentMonitor):
        if currentMonitor==0:
            self.current_screen = self.xsetup.getPrimaryScreen()
            self.current_is_primary = True
        else:
            self.current_screen = self.xsetup.getSecondaryScreen()
            self.current_is_primary = False

        self._syncGUIScreen()

    def _sendChangedSignal(self):
        self.emit(PYSIGNAL("changedSignal()"),())

    def _buildGUI(self):
        """ Assemble all GUI elements """
        # Layout stuff.
        top_layout = QHBoxLayout(self,0,KDialog.spacingHint())
        self.top_layout = top_layout

        # -- Left column with orientation and dualhead box.
        vbox = QVBox(self)
        top_layout.addWidget(vbox,0)

        # -- Orientation group
        self.orientation_group_box = QVGroupBox(vbox)
        self.orientation_group_box.setTitle(i18n("Monitor Orientation"))
        self.orientation_group_box.setInsideSpacing(KDialog.spacingHint())
        self.orientation_group_box.setInsideMargin(KDialog.marginHint())
        self.orientation_radio_group = QButtonGroup()
        self.orientation_radio_group.setRadioButtonExclusive(True)

        self.normal_orientation_radio = QRadioButton(self.orientation_group_box)
        self.normal_orientation_radio.setText(i18n("Normal"))
        self.left_orientation_radio = QRadioButton(self.orientation_group_box)
        self.left_orientation_radio .setText(i18n("Left edge on top"))
        self.right_orientation_radio = QRadioButton(self.orientation_group_box)
        self.right_orientation_radio.setText(i18n("Right edge on top"))
        self.upside_orientation_radio = QRadioButton(self.orientation_group_box)
        self.upside_orientation_radio.setText(i18n("Upsidedown"))

        self.mirror_horizontal_checkbox = QCheckBox(self.orientation_group_box)
        self.mirror_horizontal_checkbox.setText(i18n("Mirror horizontally"))
        self.connect(self.mirror_horizontal_checkbox,SIGNAL("toggled(bool)"),self.slotMirrorHorizontallyToggled)

        self.mirror_vertical_checkbox = QCheckBox(self.orientation_group_box)
        self.mirror_vertical_checkbox.setText(i18n("Mirror vertically"))
        self.connect(self.mirror_vertical_checkbox,SIGNAL("toggled(bool)"),self.slotMirrorVerticallyToggled)

        self.orientation_radio_group.insert(self.normal_orientation_radio,0)
        self.orientation_radio_group.insert(self.left_orientation_radio,1)
        self.orientation_radio_group.insert(self.right_orientation_radio,2)
        self.orientation_radio_group.insert(self.upside_orientation_radio,3)
        self.connect(self.orientation_radio_group,SIGNAL("clicked(int)"),self.slotOrientationRadioClicked)

        # -- Dualhead Box.
        self.secondary_groupbox = QVGroupBox(vbox)
        self.secondary_groupbox.setCheckable(True)
        self.secondary_groupbox.setTitle(i18n("Second screen"))
        self.connect(self.secondary_groupbox,SIGNAL("toggled(bool)"),self.slotSecondMonitorToggled)

        self.secondary_radios = QVButtonGroup(None)  # Invisible
        self.connect(self.secondary_radios,SIGNAL("pressed(int)"),self.slotSecondMonitorRadioPressed)

        self.secondary_options = {}
        self.secondary_option_ids = {}

        # Clone radio
        self.secondary_clone_radio = QRadioButton(i18n("Clone primary screen"),self.secondary_groupbox)
        radio_id = self.secondary_radios.insert(self.secondary_clone_radio)
        self.secondary_options[radio_id] = self.xsetup.LAYOUT_CLONE
        self.secondary_option_ids[self.xsetup.LAYOUT_CLONE] = radio_id

        # Dual radio
        self.secondary_dual_radio = QRadioButton(i18n("Dual screen"),self.secondary_groupbox)
        radio_id = self.secondary_radios.insert(self.secondary_dual_radio)
        self.secondary_options[radio_id] = self.xsetup.LAYOUT_DUAL
        self.secondary_option_ids[self.xsetup.LAYOUT_DUAL] = radio_id

        self.secondary_radios.setButton(radio_id)

        hbox = QHBox(self.secondary_groupbox)
        spacer = QWidget(hbox)
        spacer.setFixedSize(20,1)
        hbox.setStretchFactor(spacer,0)

        self.secondary_position_combo = QComboBox(0,hbox,"")
        self.secondary_position_combo.insertItem(i18n("1 left of 2"))
        self.secondary_position_combo.insertItem(i18n("1 right of 2"))
        self.secondary_position_combo.insertItem(i18n("1 above 2"))
        self.secondary_position_combo.insertItem(i18n("1 below 2"))
        self.connect(self.secondary_position_combo,SIGNAL("activated(int)"),self.slotSecondaryPositionChange)

        spacer = QWidget(vbox)
        vbox.setStretchFactor(spacer,1)

        vbox = QVBox(self)
        top_layout.addWidget(vbox,1)

        if not self.compact_mode:
            # -- Right columns with preview, size and refresh widgets.

            # -- Preview Box.
            self.monitor_preview_stack = QWidgetStack(vbox)

            self.monitor_preview = MonitorPreview(self.monitor_preview_stack,self.imagedir)
            self.monitor_preview_stack.addWidget(self.monitor_preview)
            self.connect(self.monitor_preview,PYSIGNAL("focussed()"),self.slotMonitorFocussed)

            self.dual_monitor_preview = DualMonitorPreview(self.monitor_preview_stack, DUAL_PREVIEW_SIZE, self.imagedir)

            self.monitor_preview_stack.addWidget(self.dual_monitor_preview)
            self.connect(self.dual_monitor_preview,PYSIGNAL("pressed()"),self.slotMonitorFocussed)
            self.connect(self.dual_monitor_preview,PYSIGNAL("positionChanged()"),self.slotDualheadPreviewPositionChanged)

        # -- Size & Refresh Box.
        if not self.compact_mode:
            hbox = QHBox(vbox)
        else:
            hbox = QVBox(vbox)
        hbox.setSpacing(KDialog.spacingHint())

        self.resize_slider = ResizeSlider(hbox)
        self.connect(self.resize_slider,PYSIGNAL("resolutionChange(int)"),self.slotResolutionChange)

        hbox2 = QHBox(hbox)
        self.refresh_label = QLabel(hbox2,"RefreshLabel")
        self.refresh_label.setText(i18n("Refresh:"))

        self.size_refresh_combo = QComboBox(0,hbox2,"comboBox1") # gets filled in setRefreshRates()
        self.connect(self.size_refresh_combo,SIGNAL("activated(int)"),self.slotRefreshRateChange)
        if self.compact_mode:
            spacer = QWidget(hbox2)
            hbox2.setStretchFactor(spacer,1)

        spacer = QWidget(vbox)
        vbox.setStretchFactor(spacer,1)

        self.clearWState(Qt.WState_Polished)

    def setNotification(self,text):
        self.notify.setText(text)

    def slotOrientationRadioClicked(self,i):
        self.current_screen.setRotation(
            [Screen.RR_Rotate_0, Screen.RR_Rotate_90,Screen.RR_Rotate_270, Screen.RR_Rotate_180][i])

        if self.current_screen.getRotation()==Screen.RR_Rotate_0:
            self.monitor_preview.setRotation(MonitorPreview.ROTATE_0)
        elif self.current_screen.getRotation()==Screen.RR_Rotate_90:
            self.monitor_preview.setRotation(MonitorPreview.ROTATE_90)
        elif self.current_screen.getRotation()==Screen.RR_Rotate_270:
            self.monitor_preview.setRotation(MonitorPreview.ROTATE_270)
        else:
            self.monitor_preview.setRotation(MonitorPreview.ROTATE_180)

        self._sendChangedSignal()

    def slotMirrorHorizontallyToggled(self,flag):
        # Bit flippin'
        if flag:
            self.current_screen.setReflection(self.current_screen.getReflection() | Screen.RR_Reflect_X)
        else:
            self.current_screen.setReflection(self.current_screen.getReflection() & ~Screen.RR_Reflect_X)
        self.monitor_preview.setReflectX(flag)
        self._sendChangedSignal()

    def slotMirrorVerticallyToggled(self,flag):
        # Bit flippin'
        if flag:
            self.current_screen.setReflection(self.current_screen.getReflection() | Screen.RR_Reflect_Y)
        else:
            self.current_screen.setReflection(self.current_screen.getReflection() & ~Screen.RR_Reflect_Y)
        self.monitor_preview.setReflectY(flag)
        self._sendChangedSignal()

    def slotResolutionChange(self,i):
        self.current_screen.setResolutionIndex(i)
        width,height = self.current_screen.getAvailableResolutions()[i]

        if not self.compact_mode:
            self.monitor_preview.setResolution(width,height)
            self.dual_monitor_preview.setScreenResolution(
                self.xsetup.getUsedScreens().index(self.current_screen),
                width,height)

        self._fillRefreshCombo()
        self._sendChangedSignal()

    def slotRefreshRateChange(self,index):
        self.current_screen.setRefreshRateIndex(index)
        self._sendChangedSignal()

    def setScreen(self,screen):
        self.current_screen = screen
        self._syncGUI()

    def slotSecondMonitorToggled(self,enabled):
        if enabled:
            pressed_id = self.secondary_radios.selectedId()
            self.xsetup.setLayout(self.secondary_options[pressed_id])
        else:
            self.xsetup.setLayout(self.xsetup.LAYOUT_SINGLE)

        if self.xsetup.getLayout()!=self.xsetup.LAYOUT_DUAL:
            self.current_screen = self.xsetup.getUsedScreens()[0]

        self.secondary_position_combo.setEnabled(self.xsetup.getLayout()==XSetup.LAYOUT_DUAL)

        self._syncGUIScreen()
        self._sendChangedSignal()

    def slotSecondMonitorRadioPressed(self,pressedId):
        self.xsetup.setLayout(self.secondary_options[pressedId])

        if self.xsetup.getLayout()!=XSetup.LAYOUT_DUAL:
            self.current_screen = self.xsetup.getUsedScreens()[0]

        self.secondary_position_combo.setEnabled(self.xsetup.getLayout()==XSetup.LAYOUT_DUAL)

        if self.xsetup.getLayout()==XSetup.LAYOUT_DUAL:
            if not self.compact_mode:
                self.monitor_preview_stack.raiseWidget(self.dual_monitor_preview)
        else:
            if not self.compact_mode:
                self.monitor_preview_stack.raiseWidget(self.monitor_preview)

        self._syncGUIScreen()
        self._sendChangedSignal()

    def slotSecondaryPositionChange(self,index):
        position = [XSetup.POSITION_LEFTOF,XSetup.POSITION_RIGHTOF,XSetup.POSITION_ABOVE,XSetup.POSITION_BELOW][index]
        self.xsetup.setDualheadOrientation(position)
        self.dual_monitor_preview.setPosition(position)
        self._sendChangedSignal()

    def slotDualheadPreviewPositionChanged(self,position):
        self.xsetup.setDualheadOrientation(position)
        index = {
            XSetup.POSITION_LEFTOF:0,
            XSetup.POSITION_RIGHTOF:1,
            XSetup.POSITION_ABOVE:2,
            XSetup.POSITION_BELOW:3
            }[position]
        self.secondary_position_combo.setCurrentItem(index)
        self._sendChangedSignal()

    def setMargin(self,margin):
        self.top_layout.setMargin(margin)

    def setSpacing(self,spacing):
        self.top_layout.setSpacing(spacing)

############################################################################
class DpmsPage(QWidget):

    # Mapping values in seconds to human-readable labels.
    intervals = (
            (60,i18n("1 minute")),
            (120,i18n("2 minutes")),
            (180,i18n("3 minutes")),
            (300,i18n("5 minutes")),
            (600,i18n("10 minutes")),
            (900,i18n("15 minutes")),
            (1200,i18n("20 minutes")),
            (1500,i18n("25 minutes")),
            (1800,i18n("30 minutes")),
            (2700,i18n("45 minutes")),
            (3600,i18n("1 hour")),
            (7200,i18n("2 hours")),
            (10800,i18n("3 hours")),
            (14400,i18n("4 hours")),
            (18000,i18n("5 hours")))

    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
        global imagedir
        QWidget.__init__(self,parent)

        # Where to find xset.
        self.xset_bin = os.popen('which xset').read()[:-1]

        if not name:
            self.setName("DPMSTab")

        dpms_tab_layout = QVBoxLayout(self,0,0,"DPMSTabLayout")
        self.top_layout = dpms_tab_layout

        hbox = QHBox(self)
        hbox.setSpacing(KDialog.spacingHint())

        dpms_tab_layout.addWidget(hbox)

        self.dpmsgroup = QHGroupBox(hbox,"dpmsgroup")
        self.dpmsgroup.setInsideSpacing(KDialog.spacingHint())
        self.dpmsgroup.setInsideMargin(KDialog.marginHint())
        self.dpmsgroup.setTitle(i18n("Enable power saving"))
        self.dpmsgroup.setCheckable(1)

        self.connect(self.dpmsgroup,SIGNAL("toggled(bool)"),self.slotDpmsToggled)

        hbox2 = QHBox(self.dpmsgroup)
        hbox2.setSpacing(KDialog.spacingHint())

        dpmstext = QLabel(hbox2,"dpmstext")
        dpmstext.setText(i18n("Switch off monitor after:"))

        self.dpmscombo = QComboBox(0,hbox2,"dpmscombo")
        self.fillCombo(self.dpmscombo)
        self.connect(self.dpmscombo,SIGNAL("activated(int)"),self.slotDpmsActivated)

        spacer = QWidget(hbox2)
        hbox2.setStretchFactor(spacer,1)

        self.energystarpix = QLabel(hbox,"energystarpix")
        self.energystarpix.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed,0,0,self.energystarpix.sizePolicy().hasHeightForWidth()))
        self.energystarpix.setMinimumSize(QSize(150,77))
        self.energystarpix.setPixmap(QPixmap(imagedir+"../energystar.png"))
        self.energystarpix.setScaledContents(1)

        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
        dpms_tab_layout.addItem(bottomspacer)

        self.clearWState(Qt.WState_Polished)

        self.readDpms()

    def fillCombo(self,combo):
        """ Fill the combobox with the values from our list """
        for interval in self.intervals:
            combo.insertItem(interval[1])

    def slotDpmsActivated(self,index):
        """ Another dpms value has been chosen, update buttons at bottom. """
        self.emit(PYSIGNAL("changedSignal()"), ())

    def slotDpmsToggled(self,bool):
        """ Dpms checkbox has been toggled, update buttons at bottom. """
        self.emit(PYSIGNAL("changedSignal()"), ())

    def readDpms(self):
         # FIXME it is not the widget's job to read or change the values, just to present the GUI.
        """ Read output from xset -q and parse DPMS settings from it. """
        # FIXME: localisation problem running this command.
        lines = ExecWithCapture(self.xset_bin,[self.xset_bin,'-q']).split('\n')

        self.dpms_min = 1800
        self.dpms_enabled = False

        for line in lines:
            if line.strip().startswith("Standby"):
                self.dpms_min = int(line.strip().split()[5]) # TODO: More subtle exception handling. ;)
            if line.strip().startswith("DPMS is"):
                self.dpms_enabled = line.strip().split()[2]=="Enabled"

        if self.dpms_min==0:    # 0 also means don't use Standby mode.
            self.dpms_enabled = False
            self.dpms_min = 1800

        self.dpmsgroup.setChecked(self.dpms_enabled)

        for i in range(len(self.intervals)):
            diff = abs(self.intervals[i][0] - self.dpms_min)
            if i==0: 
                last_diff = diff
            if (last_diff <= diff and i!=0) or (last_diff < diff):
                i = i-1
                break
            last_diff = diff
        self.dpmscombo.setCurrentItem(i)

    def isChanged(self):
        """ Check if something has changed since startup or last apply(). """
        if self.dpmsgroup.isChecked():
            if self.intervals[self.dpmscombo.currentItem()][0] != self.dpms_min:
                return True
            if self.dpmsgroup.isChecked() != self.dpms_enabled:
                return True
            return False

        else:
            # self.dpmsgroup.isChecked() is False
            return self.dpms_enabled    # self.dpms_enabled != False

    def applyDpms(self):
        """ Use xset to apply new dpms settings. """
        self.enabled = self.dpmsgroup.isChecked()
        self.seconds = self.intervals[self.dpmscombo.currentItem()][0]
        if self.enabled:
            # Switch dpms on and set timeout interval.
            cmd_on = "%s +dpms" % self.xset_bin
            cmd_set = "%s dpms %i %i %i" % (self.xset_bin, self.seconds,self.seconds,self.seconds)
            print cmd_set
            if os.system(cmd_set) != 0:
                print "DPMS command failed: ", cmd_set
        else:
            # Switch dpms off.
            cmd_on = "%s -dpms" % self.xset_bin
        if os.system(cmd_on) != 0:
            print "DPMS command failed: ", cmd_on
        self.readDpms()
        self.emit(PYSIGNAL("changedSignal()"), ())

    def apply(self):
        self.applyDpms()

    def reset(self):
        for i in range(len(self.intervals)):
            if self.intervals[i][0] == self.dpms_min:
                self.dpmscombo.setCurrentItem(i)
                break

        self.dpmsgroup.setChecked(self.dpms_enabled)

    def setMargin(self,margin):
        self.top_layout.setMargin(margin)

    def setSpacing(self,spacing):
        self.top_layout.setSpacing(spacing)

############################################################################
def create_displayconfig(parent,name):
    """ Factory function for KControl """
    global kapp
    kapp = KApplication.kApplication()
    return DisplayApp(parent, name)

############################################################################
def MakeAboutData():
    aboutdata = KAboutData("guidance",programname,version, \
        "Display and Graphics Configuration Tool", KAboutData.License_GPL, \
        "Copyright (C) 2003-2007 Simon Edwards", \
        "Thanks go to  Phil Thompson, Jim Bublitz and David Boddie.")
    aboutdata.addAuthor("Simon Edwards","Developer","[email protected]", \
            "http://www.simonzone.com/software/")
    aboutdata.addAuthor("Sebastian Kügler","Developer","[email protected]", \
            "http://vizZzion.org");
    aboutdata.addCredit("Pete Andrews","Gamma calibration pictures/system",None, \
            "http://www.photoscientia.co.uk/Gamma.htm")
    return aboutdata

if standalone:
    aboutdata = MakeAboutData()
    KCmdLineArgs.init(sys.argv,aboutdata)

    kapp = KApplication()

    displayapp = DisplayApp()
    displayapp.exec_loop()