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.
241 lines
8.0 KiB
241 lines
8.0 KiB
#-*- coding: utf-8 -*-
|
|
|
|
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import os
|
|
import sys
|
|
import re
|
|
from os import path
|
|
from calculate.lib.datavars import Variable,VariableError,ReadonlyVariable
|
|
from calculate.lib.utils.portage import isPkgInstalled
|
|
from calculate.lib.utils.files import process,STDOUT,getProgPath
|
|
from calculate.lib.utils.common import (getVideoFromXorgLog,
|
|
getVideoFromXorgConf, getVideoFromCmdLine,
|
|
getAvailableVideo, getValueFromCmdLine,
|
|
getCompositeFromXorgconf, getVideoFromModules,
|
|
getVideoFromVendor,getInstalledVideo)
|
|
|
|
from calculate.lib.cl_lang import setLocalTranslate
|
|
setLocalTranslate('cl_install3',sys.modules[__name__])
|
|
|
|
class VideoVariable(Variable):
|
|
"""
|
|
Video variables not using for flash installation
|
|
"""
|
|
xorg_need = True
|
|
|
|
def uncompatible(self):
|
|
"""
|
|
Video setting up unavailable for flash installation
|
|
"""
|
|
if self.Get('os_install_root_type') == 'flash':
|
|
return \
|
|
_("Video configuration unavailable for flash installation")
|
|
if self.Get('os_install_x11_server_set') == 'no' and self.xorg_need:
|
|
return \
|
|
_("Installed distro has not Xorg server")
|
|
return ""
|
|
|
|
class ResolutionVariable(VideoVariable):
|
|
"""
|
|
Abstract resolution variable
|
|
"""
|
|
fbres = False
|
|
def choice(self):
|
|
resolutions = ["800x600", "800x480", "640x480", "2560x1600",
|
|
"2560x1440", "2048x1152", "1920x1200", "1920x1080",
|
|
"1680x945", "1680x1050", "1600x900", "1600x768",
|
|
"1600x1200", "1440x900", "1400x1050", "1368x768",
|
|
"1366x768", "1360x768", "1280x800", "1280x768",
|
|
"1280x720", "1280x1024", "1200x800", "1024x600",
|
|
"1024x576", "1024x768"]
|
|
if self.fbres:
|
|
return map(lambda x:"%s-32"%x,
|
|
resolutions)
|
|
else:
|
|
return resolutions
|
|
|
|
def check(self,value):
|
|
"""
|
|
Check resolution format 1234x567
|
|
"""
|
|
if not re.match('^\d+x\d+(-\d+(@\d+)?)?$',value):
|
|
raise VariableError(
|
|
_("Wrong resolution {resolution} {example}").format(
|
|
resolution=value,
|
|
example="(%s:%s)"%(_("Example"),"1024x768")))
|
|
|
|
|
|
class VariableOsInstallX11Resolution(ResolutionVariable):
|
|
"""
|
|
X.org resolution
|
|
"""
|
|
type = 'choiceedit'
|
|
opt = ['-X']
|
|
metavalue = "<width>x<height>"
|
|
|
|
def init(self):
|
|
self.help = _("set Xorg resolution")
|
|
self.label = _("Screen resolution")
|
|
|
|
def get(self):
|
|
# get resolution from xorg.log
|
|
res = self.Get('os_x11_resolution')
|
|
if res or self.Get('os_install_root_type') in ('livecd','usb-hdd'):
|
|
return res
|
|
else:
|
|
return self.choice()[-1]
|
|
|
|
class VariableOsInstallX11VideoAvailable(VideoVariable):
|
|
"""
|
|
Get available (already installed or installable drivers
|
|
"""
|
|
type = "list"
|
|
|
|
def get(self):
|
|
image = self.Get('cl_image')
|
|
if image:
|
|
with image as distr:
|
|
distrPath = image.getDirectory()
|
|
if isPkgInstalled('xorg-server',prefix=distrPath):
|
|
return getAvailableVideo(prefix=distrPath)+['other']
|
|
return []
|
|
|
|
class VariableOsInstallX11VideoDrv(VideoVariable):
|
|
"""
|
|
Video driver used by xorg
|
|
"""
|
|
type = 'choice'
|
|
opt = ['--video']
|
|
metavalue = "VIDEODRV"
|
|
|
|
def init(self):
|
|
self.help = _("set the video driver")
|
|
self.label = _("{0} video driver").format("Xorg")
|
|
|
|
def choice(self):
|
|
"""Get available (already installed or installable drivers"""
|
|
return self.Get('os_install_x11_video_available')
|
|
|
|
def get(self):
|
|
# get available videodriver list from install or configure distributive
|
|
list_video = self.Choice('os_install_x11_video_drv')#getAvailableVideo(distrPath)
|
|
if not list_video:
|
|
return "other"
|
|
# if type system is usb-hdd then get detect video driver
|
|
if self.Get('os_install_root_type') == 'usb-hdd':
|
|
methods = ((getVideoFromModules,()),
|
|
(getVideoFromCmdLine,()),
|
|
(getVideoFromVendor,(self.Get('hr_video'),list_video)))
|
|
else:
|
|
# test current video driver for install system
|
|
methods = ((getVideoFromXorgLog,('/',list_video)),
|
|
(getVideoFromXorgConf,('/',)),
|
|
(getVideoFromModules,()),
|
|
(getVideoFromCmdLine,()),
|
|
(getVideoFromVendor,(self.Get('hr_video'),list_video)))
|
|
for func,args in methods:
|
|
drv = func(*args)
|
|
if drv in list_video:
|
|
return drv
|
|
return "other"
|
|
|
|
class VariableHrVideoId(ReadonlyVariable):
|
|
"""
|
|
BusID of video card
|
|
TODO: need realization
|
|
"""
|
|
value = ""
|
|
|
|
class VariableOsInstallX11Composite(VideoVariable):
|
|
"""
|
|
on/off composite
|
|
"""
|
|
type = 'bool'
|
|
opt = ['--composite']
|
|
|
|
def init(self):
|
|
self.help = _("set composite")
|
|
self.label = _("Composite")
|
|
|
|
def get(self):
|
|
"""On/off composite"""
|
|
defaultCompositeOn = ("nvidia","intel","fglrx","nouveau","radeon")
|
|
composite = getValueFromCmdLine("calculate",5)
|
|
videodrv = getValueFromCmdLine("calculate",4)
|
|
if videodrv != "auto":
|
|
composite = {'nocomposite':'off',
|
|
'off':'off',
|
|
'on':'on',
|
|
'composite':'on'}.get(composite)
|
|
else:
|
|
composite = None
|
|
|
|
if self.Get('os_install_x11_video_drv') in defaultCompositeOn:
|
|
defaultComposite = "on"
|
|
else:
|
|
defaultComposite = "off"
|
|
if self.Get('os_install_x11_video_drv') == self.Get('os_x11_video_drv'):
|
|
state = getCompositeFromXorgconf()
|
|
else:
|
|
state = None
|
|
return composite or state or defaultComposite
|
|
|
|
class VariableOsInstallFbResolution(ResolutionVariable):
|
|
"""
|
|
Framebuffer resolution
|
|
"""
|
|
type = 'choiceedit'
|
|
opt = ['--fb']
|
|
metavalue = "<width>x<height>"
|
|
xorg_need = False
|
|
fbres = True
|
|
|
|
def init(self):
|
|
self.help = _("set framebuffer resolution")
|
|
self.label = _("Framebuffer resolution")
|
|
|
|
def get(self):
|
|
"""Get current framebuffer resolution"""
|
|
resolution = ""
|
|
fbres = getProgPath('/sbin/fbres')
|
|
if fbres:
|
|
processFbres = process(fbres,stderr=STDOUT)
|
|
textLines = processFbres.readlines()
|
|
if textLines:
|
|
cxx11,cyx11 = \
|
|
self.Get('os_install_x11_resolution').partition('x')[0::2]
|
|
cxfb, cyfb = textLines[0].partition('x')[0::2]
|
|
if not filter(lambda x:not x.isdigit(),
|
|
[cxfb,cyfb,cxx11,cyx11])and \
|
|
int(cxx11) >= int(cxfb) and int(cyx11) >= int(cyfb):
|
|
resolution = "%s-32"%textLines[0]
|
|
return resolution or "1024x768-32"
|
|
|
|
class VariableOsInstallX11ServerSet(ReadonlyVariable):
|
|
"""
|
|
Is install xorg-server
|
|
"""
|
|
type = "bool"
|
|
|
|
def get(self):
|
|
image = self.Get('cl_image')
|
|
if image:
|
|
with image as distr:
|
|
distrPath = image.getDirectory()
|
|
if isPkgInstalled('xorg-server',prefix=distrPath):
|
|
return "yes"
|
|
return "no"
|