Logo Search packages:      
Sourcecode: kde-guidance version File versions  Download package

displayconfigwidgets.py

from qt import *
from kdecore import *
from kdeui import *
import os
from displayconfigabstraction import *

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

############################################################################
00012 class ResizeSlider(QVGroupBox):
    """ An abstracted QSlider in a nice box to change the resolution of a screen """
    def __init__(self,parent):
        # Screen size group
        QVGroupBox.__init__(self,parent)
        self.updating_gui = True
        self._buildGUI()
        self.updating_gui = False
    
    def _buildGUI(self):
        self.setTitle(i18n("Screen Size"))
        self.setInsideSpacing(KDialog.spacingHint())
        self.setInsideMargin(KDialog.marginHint())
        
        hbox3 = QHBox(self)
        hbox3.setSpacing(KDialog.spacingHint())
        label = QLabel(hbox3,"textLabel2_4")
        label.setText(i18n("Lower"))
        self.screensizeslider = QSlider(hbox3,"slider1")
        self.screensizeslider.setMinValue(0)
        self.screensizeslider.setMaxValue(4)
        self.screensizeslider.setPageStep(1)
        self.screensizeslider.setOrientation(QSlider.Horizontal)
        self.screensizeslider.setTickmarks(QSlider.Below)
        self.connect(self.screensizeslider,SIGNAL("valueChanged(int)"),self.slotResolutionChange)
        label = QLabel(hbox3)
        label.setText(i18n("Higher"))

        self.resolutionlabel = QLabel(self)
        self.resolutionlabel.setText("640x400")

    def setScreen(self, screen):
        self.updating_gui = True
        self.screen = screen
        self.screensizeslider.setMaxValue(len(screen.getAvailableResolutions())-1)
        self.screensizeslider.setValue(screen.getResolutionIndex())
        self.updating_gui = False
        self.setResolutionIndex(screen.getResolutionIndex())
        
00051     def slotResolutionChange(self,i):
        """ Pass signal from slider through to App """
        if self.updating_gui:
            return
        self.setResolutionIndex(i)
        self.emit(PYSIGNAL("resolutionChange(int)"),(i,))

    def setMaxValue(self,value):
        self.updating_gui = True
        self.screensizeslider.setMaxValue(value)
        self.updating_gui = False
        
    def setMinValue(self,value):
        self.updating_gui = True
        self.screensizeslider.setMinValue(value)
        self.updating_gui = False

    def setValue(self,value):
        self.updating_gui = True
        self.screensizeslider.setValue(value)
        self.updating_gui = False
        
    def value(self):
        return self.screensizeslider.value()
        
    def setResolutionLabel(self,text):
        self.resolutionlabel.setText(text) 
    
    def setResolutionIndex(self,i):
        self.updating_gui = True
        width,height = self.screen.getAvailableResolutions()[i]
        self.setResolutionLabel(i18n("%1 x %2").arg(width).arg(height))
        self.updating_gui = False

############################################################################
00086 class MonitorPreview(QWidget):
    """ A ResizableMonitor is an Image in a grid which has resizable edges, 
        fixed-size corners and is thus expandable. """
    ROTATE_0 = 0
    ROTATE_90 = 1
    ROTATE_180 = 2
    ROTATE_270 = 3

    def __init__(self, parent=None, imagedir="", name=None):
        QWidget.__init__(self,parent)
        
        self.rotation = MonitorPreview.ROTATE_0
        
        self.screen_width = 1280
        self.screen_height = 1024
        
        self.reflect_x = False
        self.reflect_y = False
       
        self.setBackgroundMode(Qt.NoBackground)
        
        self.imagedir = imagedir + "monitor_resizable/"

        self.image_monitor = QPixmap(self.imagedir+"monitor.png")
        self.image_monitor_wide = QPixmap(self.imagedir+"monitor_wide.png")
        self.image_monitor_r90 = QPixmap(self.imagedir+"monitor_r90.png")
        self.image_monitor_wide_r90 = QPixmap(self.imagedir+"monitor_wide_r90.png")
        
        self.image_background = QPixmap(self.imagedir+"background.png")
        self.image_background_wide = QPixmap(self.imagedir+"background_wide.png")
        self.image_background_r90 = QPixmap(self.imagedir+"background_r90.png")
        self.image_background_wide_r90 = QPixmap(self.imagedir+"background_wide_r90.png")
        
        self.image_window = QPixmap(self.imagedir+"window_4th.png")
        self.image_window_bottom_left = QPixmap(self.imagedir+"window_bottom_left_4th.png")
        self.image_window_bottom_right = QPixmap(self.imagedir+"window_bottom_right_4th.png")

    def sizeHint(self):
        max_width = max(self.image_monitor.width(), self.image_monitor_wide.width(),
                        self.image_monitor_r90.width(), self.image_monitor_wide_r90.width())
        max_height = max(self.image_monitor.height(), self.image_monitor_wide.height(),
                        self.image_monitor_r90.height(), self.image_monitor_wide_r90.height())
        return QSize(max_width, max_height)
    
    def sizePolicy(self):
        return QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        
    def paintEvent(self,paint_event):
        screen_width = self.screen_width
        screen_height = self.screen_height
        
        # Widescreen format: preview width: 176, height: 99, 16:9
        is_wide = abs(float(screen_width)/float(screen_height)-16.0/9.0) < 0.2
        
        if not is_wide:
            preview_screen_width = 152
            preview_screen_height = 114
        else:
            preview_screen_width = 176
            preview_screen_height = 99
        
        if self.rotation==MonitorPreview.ROTATE_0 or self.rotation==MonitorPreview.ROTATE_180:
            # Normal, landscape orientation.
            if not is_wide:
                screen_x_offset = 23
                screen_y_offset = 15
                image_background = self.image_background
            else:
                screen_x_offset = 23
                screen_y_offset = 29
                image_background = self.image_background_wide
        else:
            # Portrait orientation. Swap some values around.
            t = preview_screen_width
            preview_screen_width = preview_screen_height
            preview_screen_height = t
            
            t = screen_width
            screen_width = screen_height
            screen_height = t
            
            if not is_wide:
                screen_x_offset = 42
                screen_y_offset = 15
                image_background = self.image_background_r90
            else:
                screen_x_offset = 50
                screen_y_offset = 15
                image_background = self.image_background_wide_r90
                
        # Draw everything off screen in a buffer
        preview_buffer = QPixmap(preview_screen_width,preview_screen_height)
        painter = QPainter(preview_buffer)
        
        # Draw the background on the monitor's screen
        painter.drawPixmap(0, 0, image_background)
        
        # Work out the scaling factor for the eye candy in the preview winodw.
        scale_factor = 4.0*float(preview_screen_width) / float(screen_width)
        transform_matrix = QWMatrix().scale(scale_factor,scale_factor)
        
        # Draw the little window on the background
        scaled_window = self.image_window.xForm(transform_matrix)
        
        sx = (preview_screen_width-scaled_window.width())/2
        sy = (preview_screen_height-scaled_window.height())/2
        if sx < 0:
            sx = 0 
        if sy < 0:
            sy = 0
        sw = scaled_window.width()
        if sw>preview_screen_width:
            sw = preview_screen_width
            
        sh = scaled_window.height()
        if sh>preview_screen_height:
            sh = preview_screen_height
        
        painter.drawPixmap(sx, sy, scaled_window, 0, 0, sw, sh)
        
        # Now draw the clock in the lower right corner
        scaled_window = self.image_window_bottom_right.xForm(transform_matrix)
        
        sx = preview_screen_width - scaled_window.width()
        sy = preview_screen_height - scaled_window.height()
        sw = scaled_window.width()#preview_screen_width/2
        sh = scaled_window.height()
        
        sx_offset = 0
        if sx<0: # Some simple clipping for the left edge
            sx_offset = -sx
            sw = preview_screen_width
            sx = 0

        painter.drawPixmap(sx, sy, scaled_window, sx_offset, 0, sw, sh)
        
        # Now draw the k menu in the lower left corner
        scaled_window = self.image_window_bottom_left.xForm(transform_matrix)
        
        sx = 0
        sy = preview_screen_height - scaled_window.height()
        sw = preview_screen_width/2 # Just draw on the left side of the preview.
        sh = scaled_window.height()
        painter.drawPixmap(sx, sy, scaled_window, 0, 0, sw, sh)
        painter.end()
        
        # Transform the preview image. Do reflections.
        reflect_x = 1
        if self.reflect_x:
            reflect_x = -1
        reflect_y = 1
        if self.reflect_y:
            reflect_y = -1
            
        preview_buffer = preview_buffer.xForm(QWMatrix().scale(reflect_x,reflect_y))
        
        # Draw the monitor on another buffer.
        off_screen_buffer = QPixmap(self.width(),self.height())
        off_screen_painter = QPainter(off_screen_buffer)
        
        # Erase the buffer first
        off_screen_painter.setBackgroundColor(self.paletteBackgroundColor())
        off_screen_painter.eraseRect(0, 0, off_screen_buffer.width(), off_screen_buffer.height())
        
        if self.rotation==MonitorPreview.ROTATE_0 or self.rotation==MonitorPreview.ROTATE_180:
            if not is_wide:
                image_monitor = self.image_monitor
            else:
                image_monitor = self.image_monitor_wide
        else:
            if not is_wide:
                image_monitor = self.image_monitor_r90
            else:
                image_monitor = self.image_monitor_wide_r90
                
        top_edge = self.height()-image_monitor.height()
        left_edge = (self.width()-image_monitor.width())/2
        
        # Draw the monitor
        off_screen_painter.drawPixmap(left_edge, top_edge, image_monitor)
        off_screen_painter.end()
        
        # Copy the preview onto the off screen buffer with the monitor.
        bitBlt(off_screen_buffer, left_edge+screen_x_offset, top_edge+screen_y_offset, preview_buffer,
                0, 0, preview_buffer.width(), preview_buffer.height(),Qt.CopyROP, False)
        
        # Update the widget
        bitBlt(self, 0, 0, off_screen_buffer, 0, 0, self.width(), self.height(), Qt.CopyROP, False)
        
    def setResolution(self,width,height):
        self.screen_width = width
        self.screen_height = height
        self.update()

    def setRotation(self, rotation):
        self.rotation = rotation
        self.update()
        
    def setReflectX(self, enable):
        self.reflect_x = enable
        self.update()
        
    def setReflectY(self, enable):
        self.reflect_y = enable
        self.update()
        
############################################################################
00293 class DualMonitorPreview(QWidget):
    """ This is the Widget to use elsewhere. It consists of a canvas and an
        arbitrary number of gizmos on the canvas. The gizmos can be dragged and 
        dropped around. Painting is double-buffered so flickering should not occur.
    """
    def __init__(self, parent, size, imagedir):
        QWidget.__init__(self,parent)
        self.setBackgroundMode(Qt.NoBackground)
        
        self.imagedir = imagedir + "dualhead/"
        self.snap_distance = 25
        self.snapping = True
        self.size = size
        self.position = XSetup.POSITION_LEFTOF
       
        self.current_screen = 0
        
        self.resize(size,size)
        self.setMouseTracking(True)

        self.gizmos = []
        self.gizmos.append(MovingGizmo("Monitor 1","monitor_1.png",QPoint(20,50),self.imagedir))
        self.gizmos.append(MovingGizmo("Monitor 2","monitor_2.png",QPoint(180,50),self.imagedir))
        
        self.gizmos[0].setWidth(1280)
        self.gizmos[0].setHeight(1024)
        self.gizmos[0].setHighlightColor(self.colorGroup().highlight())
        self.gizmos[1].setWidth(1280)
        self.gizmos[1].setHeight(1024)
        self.gizmos[1].setHighlightColor(self.colorGroup().highlight())
        
        self.dragging = False
        self.dragging_gizmo = 0
        self.drag_handle = None
        
        self._positionGizmos()
        self.setCurrentScreen(0)
        
    def minimumSizeHint(self):
        return QSize(self.size,self.size)
        
    def setCurrentScreen(self,screen):
        self.current_screen = screen
        self.gizmos[0].setHighlight(screen==0)
        self.gizmos[1].setHighlight(screen==1)
        self.update()
        
    def getCurrentScreen(self):
        return self.current_screen
        
    def setPosition(self,position):
        self.position = position
        self._positionGizmos()
        self.update()
        
00348     def getPosition(self):
        """Returns one of XSetup.POSITION_LEFTOF, XSetup.POSITION_RIGHTOF,
        XSetup.POSITION_ABOVE or XSetup.POSITION_BELOW.
        """
        return self.position
    
    def setScreenResolution(self,screenNumber,width,height):
        self.gizmos[screenNumber].setWidth(width)
        self.gizmos[screenNumber].setHeight(height)
        self.setPosition(self.position) # Reposition and force update.
    
    def _positionGizmos(self):
        g1 = self.gizmos[0]
        g2 = self.gizmos[1]
    
        # Treat POSITION_RIGHTOF and POSITION_BELOW as LEFTOF and ABOVE with the
        # gizmos swapped around.
        if self.position==XSetup.POSITION_RIGHTOF or self.position==XSetup.POSITION_BELOW:
            tmp = g1
            g1 = g2
            g2 = tmp
        
        if self.position==XSetup.POSITION_LEFTOF or self.position==XSetup.POSITION_RIGHTOF:
            x = -g1.getWidth()
            y = -max(g1.getHeight(), g2.getHeight())/2
            g1.setPosition(QPoint(x,y))
            
            x = 0
            g2.setPosition(QPoint(x,y))
            
        else:
            x = -max(g1.getWidth(), g2.getWidth())/2
            y = -g1.getHeight()
            g1.setPosition(QPoint(x,y))
            
            y = 0
            g2.setPosition(QPoint(x,y))
        
    def mousePressEvent(self,event):
        # Translate the point in the window into our gizmo space.
        world_point = self._getGizmoMatrix().invert()[0].map(event.pos())

        # If the mouse is in the air space of a gizmo, then we change the cursor to
        # indicate that the gizmo can be dragged.
        for giz in self.gizmos:
            if giz.getRect().contains(world_point):
                self.setCurrentScreen(self.gizmos.index(giz))
                break
        else:
            return
            
        # Pressing down the mouse button on a gizmo also starts a drag operation.
        self.dragging = True
        self.dragging_gizmo = self.getCurrentScreen()
        self.drag_handle = world_point - self.gizmos[self.dragging_gizmo].getPosition()
        
        # Let other people know that a gizmo has been selected.
        self.emit(PYSIGNAL("pressed()"), (self.current_screen,) )
        
    def mouseReleaseEvent(self,event):
        if not self.dragging:
            return
            
        # Translate the point in the window into our gizmo space.
        world_point = self._getGizmoMatrix().invert()[0].map(event.pos())

        if self._moveGizmo(world_point):
            self.setPosition(self.drag_position)
            self.emit(PYSIGNAL("positionChanged()"), (self.position,) )
        else:
            self.setPosition(self.position)
        self.dragging = False
    
    def mouseMoveEvent(self,event):
        # Translate the point in the window into our gizmo space.
        world_point = self._getGizmoMatrix().invert()[0].map(event.pos())

        # If the mouse is in the air space of a gizmo, then we change the cursor to
        # indicate that the gizmo can be dragged.
        for giz in self.gizmos:
            if giz.getRect().contains(world_point):
                self.setCursor(QCursor(Qt.SizeAllCursor))
                break
        else:
            self.unsetCursor()
        
        if self.dragging:
            self._moveGizmo(world_point)
            self.update()
    
        return

    def _moveGizmo(self,worldPoint):
        new_drag_position = worldPoint-self.drag_handle
        
        # Drag gizmo is simply the thing being dragged.
        drag_gizmo = self.gizmos[self.dragging_gizmo]
        drag_x = new_drag_position.x()
        drag_y = new_drag_position.y()
        
        # Snap gizmo is other (stationary) thing that we "snap" against.
        snap_gizmo = self.gizmos[1-self.dragging_gizmo]
        snap_x = snap_gizmo.getPosition().x()
        snap_y = snap_gizmo.getPosition().y()
        
        # Calculate the list of "snap points".
        snap_points = [
            (snap_x-drag_gizmo.getWidth(), snap_y),     # Left of 
            (snap_x+snap_gizmo.getWidth(), snap_y),     # Right of 
            (snap_x, snap_y-drag_gizmo.getHeight()),    # Above
            (snap_x, snap_y+snap_gizmo.getHeight())]    # Below
        
        # Find the snap point that the drag gizmo is closest to.
        best_index = -1
        best_distance = 0
        i = 0
        for snap_point in snap_points:
            dx = snap_point[0] - drag_x
            dy = snap_point[1] - drag_y
            distance_squared = dx*dx + dy*dy
            if best_index==-1 or distance_squared < best_distance:
                best_index = i
                best_distance = distance_squared
            i += 1
        
        # Lookup the best dualhead position that this configuration matches.
        if self.dragging_gizmo==0:
            self.drag_position = [
                XSetup.POSITION_LEFTOF,
                XSetup.POSITION_RIGHTOF,
                XSetup.POSITION_ABOVE,
                XSetup.POSITION_BELOW][best_index]
        else:
            self.drag_position = [
                XSetup.POSITION_RIGHTOF,
                XSetup.POSITION_LEFTOF,
                XSetup.POSITION_BELOW,
                XSetup.POSITION_ABOVE][best_index]
        
        # Convert the auto-snap distance in pixels into a distance in the gizmo coordinate system.
        world_snap_distance = self.snap_distance / self._getGizmoToPixelsScaleFactor()

        # Should this drag gizmo visually snap?
        snapped = False
        if best_distance <= (world_snap_distance*world_snap_distance):
            new_drag_position = QPoint(snap_points[best_index][0],snap_points[best_index][1])
            snapped = True
            
        # Move the gizmo
        self.gizmos[self.dragging_gizmo].setPosition(new_drag_position)
        
        return snapped
        
    def paintEvent(self,event=None):
        QWidget.paintEvent(self,event)

        # Paint to an off screen buffer first. Later we copy it to widget => flicker free.
        off_screen_buffer = QPixmap(self.width(),self.height())
        off_screen_painter = QPainter(off_screen_buffer)
        
        # Erase the buffer first
        off_screen_painter.setBackgroundColor(self.colorGroup().mid() )
        off_screen_painter.eraseRect(0, 0, off_screen_buffer.width(), off_screen_buffer.height())
       
        # 
        off_screen_painter.setWorldMatrix(self._getGizmoMatrix())
        
        # Paint the non-selected gizmo first.
        self.gizmos[ 1-self.current_screen ].paint(off_screen_painter)
        
        # Now paint the selected gizmo
        self.gizmos[self.current_screen].paint(off_screen_painter)
            
        # Turn off the world matrix transform.
        off_screen_painter.setWorldXForm(False)
        
        # Draw the rounded border
        off_screen_painter.setPen(QPen(self.colorGroup().dark(),1))
        off_screen_painter.drawRoundRect(0,0,self.width(),self.height(),2,2)
           
        off_screen_painter.end()
        
        # Update the widget
        bitBlt(self, 0, 0, off_screen_buffer, 0, 0, self.width(), self.height(), Qt.CopyROP, False)
    
    def _getGizmoMatrix(self):
        matrix = QWMatrix()
        matrix.translate(self.width()/2,self.height()/2)
        
        scale_factor = self._getGizmoToPixelsScaleFactor()
        matrix.scale(scale_factor,scale_factor)
        return matrix
        
    def _getGizmoToPixelsScaleFactor(self):
        g1 = self.gizmos[0]
        g2 = self.gizmos[1]
        size = min(self.width(),self.height())
        vscale = float(self.height()) / (2.1 * (g1.getHeight()+g2.getHeight()))
        hscale = float(self.width()) / (2.1 * (g1.getWidth()+g2.getWidth()))
        return min(vscale,hscale)
        
############################################################################
00550 class MovingGizmo(object):
    """A gizmo represents a screen/monitor. It also has a width and height that
    correspond to the resolution of screen."""
    
    def __init__(self,label,filename,initial_pos=QPoint(0,0),imagedir="."):
        self.width = 100
        self.height = 100
        self.pixmap = QPixmap(imagedir+filename)

        self.highlight = False
        self.highlight_color = QColor(255,0,0)
        
        self.setPosition(initial_pos)
        
        # Used for caching the scaled pixmap.
        self.scaled_width = -1
        self.scaled_height = -1
        
    def setHighlight(self,enable):
        self.highlight = enable
    
    def setHighlightColor(self,color):
        self.highlight_color = color
    
    def setPosition(self,position):
        self.position = position
        
    def getSize(self):
        return QSize(self.width,self.height)
        
    def getPosition(self):
        return self.position
    
    def getRect(self):
        return QRect(self.position,self.getSize())
    
    def setWidth(self,width):
        self.width = width
        
    def getWidth(self):
        return self.width
        
    def setHeight(self,height):
        self.height = height
    
    def getHeight(self):
        return self.height
    
    def paint(self,painter):
        painter.save()
        if self.highlight:
            pen = QPen(self.highlight_color,6)
            painter.setPen(pen)
            
            painter.drawRect(self.position.x(), self.position.y(), self.width, self.height)
        
        to_pixels_matrix = painter.worldMatrix()
        top_left_pixels = to_pixels_matrix.map(self.position)
        bottom_right_pixels = to_pixels_matrix.map( QPoint(self.position.x()+self.width, self.position.y()+self.height) )
        
        # Scale the pixmap.
        scaled_width = bottom_right_pixels.x() - top_left_pixels.x()
        scaled_height = bottom_right_pixels.y() - top_left_pixels.y()
        
        if (scaled_width,scaled_height) != (self.scaled_width,self.scaled_height):
            scale_matrix = QWMatrix()
            scale_matrix.scale(
                float(scaled_width)/float(self.pixmap.width()),
                float(scaled_height)/float(self.pixmap.height()) )
                
            self.scaled_pixmap = self.pixmap.xForm(scale_matrix)
            (self.scaled_width,self.scaled_height) = (scaled_width,scaled_height)
        
        # Paste in the scaled pixmap.
        bitBlt(painter.device(), top_left_pixels.x(), top_left_pixels.y(), self.scaled_pixmap, 0, 0,
            self.scaled_pixmap.width(), self.scaled_pixmap.height(),Qt.CopyROP, False)
        
        painter.restore()

############################################################################
class GfxCardWidget(QVGroupBox):
    def __init__(self, parent, xsetup, gfxcard, gfxcarddialog, monitordialog):
        global imagedir
        QVGroupBox.__init__(self,parent)

        self.xsetup = xsetup
        self.gfxcard = gfxcard
        self.gfxcarddialog = gfxcarddialog
        self.monitordialog = monitordialog
        self._buildGUI()
        self._syncGUI()
        
    def _buildGUI(self):
        # Create the GUI    
        
        gridwidget = QWidget(self)
        grid = QGridLayout(gridwidget,2+3*len(self.gfxcard.getScreens()))
        grid.setSpacing(KDialog.spacingHint())
        grid.setColStretch(0,0)
        grid.setColStretch(1,0)
        grid.setColStretch(2,0)
        grid.setColStretch(3,1)
        grid.setColStretch(4,0)
        
        gfxcardpic = QLabel(gridwidget)
        gfxcardpic.setPixmap(UserIcon('hi32-gfxcard'))
        grid.addMultiCellWidget(gfxcardpic,0,1,0,0)
        
        label = QLabel(gridwidget)
        label.setText(i18n("Graphics card:"))
        grid.addWidget(label,0,1)
        
        self.gfxcardlabel = QLabel(gridwidget)
        grid.addWidget(self.gfxcardlabel,0,2)
        
        label = QLabel(gridwidget)
        label.setText(i18n("Driver:"))
        grid.addWidget(label,1,1)
        
        self.driverlabel = QLabel(gridwidget)
        grid.addMultiCellWidget(self.driverlabel,1,1,2,3)
        
        gfxbutton = QPushButton(gridwidget)
        gfxbutton.setText(i18n("Configure..."))
        self.connect(gfxbutton,SIGNAL("clicked()"),self.slotGfxCardConfigureClicked)
        grid.addWidget(gfxbutton,0,4)
        gfxbutton.setEnabled(self.xsetup.mayModifyXorgConfig())
        
        # Add all of the screens
        row = 2
        count = 1
        self.monitorlabels = []
        self.monitor_buttons = []
        self.monitor_roles = []
        for screen in self.gfxcard.getScreens():
            frame = QFrame(gridwidget)
            frame.setFrameShape(QFrame.HLine)
            frame.setFrameShadow(QFrame.Sunken)
            grid.addMultiCellWidget(frame,row,row,0,4)
            row += 1
            
            monitorpic = QLabel(gridwidget)
            monitorpic.setPixmap(UserIcon('hi32-display'))
            grid.addMultiCellWidget(monitorpic,row,row+1,0,0)
    
            # Monitor label
            label = QLabel(gridwidget)
            if len(self.gfxcard.getScreens())==1:
                label.setText(i18n("Monitor:"))
            else:
                label.setText(i18n("Monitor #%1:").arg(count))
            grid.addWidget(label,row,1)
            
            self.monitorlabels.append(QLabel(gridwidget))
            grid.addMultiCellWidget(self.monitorlabels[-1],row,row,2,3)
    
            # Role pulldown
            if len(self.xsetup.getAllScreens())!=1:
                label = QLabel(gridwidget)
                label.setText(i18n("Role:"))
                grid.addWidget(label,row+1,1)
                
                role_combo = KComboBox(False,gridwidget)
                role_combo.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
                self.monitor_roles.append(role_combo)
                role_combo.insertItem(i18n("Primary (1)"))
                role_combo.insertItem(i18n("Secondary (2)"))
                if len(self.xsetup.getAllScreens())>=3:
                    role_combo.insertItem(i18n("Unused"))
                self.connect(role_combo,SIGNAL("activated(int)"),self.slotRoleSelected)
                grid.addWidget(role_combo,row+1,2)
                role_combo.setEnabled(self.xsetup.mayModifyXorgConfig())
    
            monitorbutton = QPushButton(gridwidget)
            self.monitor_buttons.append(monitorbutton)
            monitorbutton.setText(i18n("Configure..."))
            self.connect(monitorbutton,SIGNAL("clicked()"),self.slotMonitorConfigureClicked)
            grid.addWidget(monitorbutton,row,4)
            monitorbutton.setEnabled(self.xsetup.mayModifyXorgConfig())
            row += 2
            count += 1
            
    def syncConfig(self):
        self._syncGUI()
        
    def _syncGUI(self):
        if self.gfxcard.getGfxCardModel() is not None:
            self.setTitle(self.gfxcard.getGfxCardModel().getName())
            self.gfxcardlabel.setText(self.gfxcard.getGfxCardModel().getName())
            
            if self.gfxcard.isProprietaryDriver():
                self.driverlabel.setText(self.gfxcard.getGfxCardModel().getProprietaryDriver())
            else:
                self.driverlabel.setText(self.gfxcard.getGfxCardModel().getDriver())
        else:
            self.setTitle(i18n("<Unknown>"))
            self.gfxcardlabel.setText(i18n("<Unknown>"))
            self.driverlabel.setText(i18n("<none>"))
        
        # Sync the screens and monitors.
        for i in range(len(self.gfxcard.getScreens())):
            screen = self.gfxcard.getScreens()[i]
            
            if screen.getMonitorModel() is None:
                monitor_name = i18n("<unknown>")
            else:
                monitor_name = QString(screen.getMonitorModel().getName())
            if screen.getMonitorAspect()==ModeLine.ASPECT_16_9:
                monitor_name.append(i18n(" (widescreen)"))
            self.monitorlabels[i].setText(monitor_name)
            
            if len(self.xsetup.getAllScreens())!=1:
                self.monitor_roles[i].setCurrentItem(
                    {XSetup.ROLE_PRIMARY: 0,
                    XSetup.ROLE_SECONDARY: 1,
                    XSetup.ROLE_UNUSED: 2}
                    [self.xsetup.getScreenRole(screen)])
                
    def slotGfxCardConfigureClicked(self):
        result = self.gfxcarddialog.do(self.gfxcard.getGfxCardModel(), \
            self.gfxcard.isProprietaryDriver(), self.gfxcard.getDetectedGfxCardModel(),
            self.gfxcard.getVideoRam())
            
        (new_card_model, new_proprietary_driver, new_video_ram) = result
        
        if new_card_model is self.gfxcard.getGfxCardModel() and \
                new_proprietary_driver==self.gfxcard.isProprietaryDriver() and \
                new_video_ram==self.gfxcard.getVideoRam():
            return
        self.gfxcard.setGfxCardModel(new_card_model)
        self.gfxcard.setProprietaryDriver(new_proprietary_driver)
        self.gfxcard.setVideoRam(new_video_ram)
        self._syncGUI()
        self.emit(PYSIGNAL("configChanged"), () )
        
    def slotMonitorConfigureClicked(self):
        screen_index = self.monitor_buttons.index(self.sender())
        screen_obj = self.gfxcard.getScreens()[screen_index]
        
        (new_monitor_model,new_aspect) = self.monitordialog.do(screen_obj.getMonitorModel(),
            screen_obj.getMonitorAspect(),
            self.xsetup.getGfxCards()[0].getScreens()[0] is screen_obj)
            
        screen_obj.setMonitorModel(new_monitor_model)
        screen_obj.setMonitorAspect(new_aspect)
        self._syncGUI()
        self.emit(PYSIGNAL("configChanged"), () )
        
    def slotRoleSelected(self,index):
        screen_index = self.monitor_roles.index(self.sender())        
        screen_obj = self.gfxcard.getScreens()[screen_index]
        self.xsetup.setScreenRole(screen_obj,[XSetup.ROLE_PRIMARY,XSetup.ROLE_SECONDARY,XSetup.ROLE_UNUSED][index])
        
        self._syncGUI()
        self.emit(PYSIGNAL("configChanged"), () )

Generated by  Doxygen 1.6.0   Back to index