diff options
Diffstat (limited to 'displayconfig/displayconfigwidgets.py')
| -rw-r--r-- | displayconfig/displayconfigwidgets.py | 809 |
1 files changed, 0 insertions, 809 deletions
diff --git a/displayconfig/displayconfigwidgets.py b/displayconfig/displayconfigwidgets.py deleted file mode 100644 index 009fe7e..0000000 --- a/displayconfig/displayconfigwidgets.py +++ /dev/null @@ -1,809 +0,0 @@ - -from qt import * -from tdecore import * -from tdeui import * -import os -from displayconfigabstraction import * - -# Running as the root user or not? -isroot = os.getuid()==0 - -############################################################################ -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()) - - 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 - -############################################################################ -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() - -############################################################################ -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() - - 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) - -############################################################################ -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(): - try: - # Displayconfig thinks there is a proprietary driver - self.driverlabel.setText(self.gfxcard.getGfxCardModel().getProprietaryDriver()) - except TypeError, errormsg: - # If there isn't it dies, so try again LP: #198269 - self.driverlabel.setText(self.gfxcard.getGfxCardModel().getDriver()) - 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"), () ) |