TDE
/
tde-guidance
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tde-guidance
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3c9bf533ff'
${ noResults }
tde-guidance/displayconfig/displayconfig.py

1757 lines
71 KiB
Raw Normal View History Unescape

Added KDE3 version of KDE Guidance utilities git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kde-guidance@1102646 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
15 years ago
#!/usr/bin/python
# -*- coding: UTF-8 -*-
###########################################################################
# displayconfig.py - description #
# ------------------------------ #
# begin : Fri Mar 26 2004 #
# copyright : (C) 2004-2006 by Simon Edwards #
# email : simon@simonzone.com #
# #
###########################################################################
# #
# 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 kdecore import *
from kdeui 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","simon@simonzone.com", \
"http://www.simonzone.com/software/")
aboutdata.addAuthor("Sebastian Kügler","Developer","sebas@kde.org", \
"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()