Python QtWidgets.QScrollArea类代码示例

    def widgetImage(self):
        """Create main image display.
        """
        imageArea = QHBoxLayout()
        scroll = QScrollArea()
        scroll.setAlignment(QtCore.Qt.AlignCenter)
        self.imageLabel = QLabel(self)

        scroll.setWidget(self.imageLabel)
        next = QPushButton(self.tr('>'))
        next.clicked.connect(self.nextCluster)
        prev = QPushButton(self.tr('<'))
        prev.clicked.connect(self.prevCluster)
        imageArea.addWidget(prev)
        imageArea.addWidget(scroll)
        imageArea.addWidget(next)

        vbox = QVBoxLayout()
        self.clusterCountLabel = QLabel(self)
        self.clusterCountLabel.setAlignment(QtCore.Qt.AlignCenter)
        f = QtGui.QFont('Arial', 14, QtGui.QFont.Bold);
        self.clusterCountLabel.setFont(f)
        vbox.addWidget(self.clusterCountLabel)
        vbox.addLayout(imageArea)
        return vbox

    def __init__(self, parent=None):
        super(SourceWidget, self).__init__(parent)

        self.mimeData = None

        imageFile = QFile(':/images/example.svg')
        imageFile.open(QIODevice.ReadOnly)
        self.imageData = imageFile.readAll()
        imageFile.close()

        imageArea = QScrollArea()
        self.imageLabel = QSvgWidget()
        self.imageLabel.renderer().load(self.imageData)
        imageArea.setWidget(self.imageLabel)

        instructTopLabel = QLabel("This is an SVG drawing:")
        instructBottomLabel = QLabel("Drag the icon to copy the drawing as a PNG file:")
        dragIcon = QPushButton("Export")
        dragIcon.setIcon(QIcon(':/images/drag.png'))
        dragIcon.pressed.connect(self.startDrag)

        layout = QGridLayout()
        layout.addWidget(instructTopLabel, 0, 0, 1, 2)
        layout.addWidget(imageArea, 1, 0, 2, 2)
        layout.addWidget(instructBottomLabel, 3, 0)
        layout.addWidget(dragIcon, 3, 1)
        self.setLayout(layout)
        self.setWindowTitle("Delayed Encoding")

    def initView(self):
        '''创建界面'''
        scrollArea = QScrollArea(self)    # 滚动区域
        scrollArea.setWidgetResizable(True)
        self.setCentralWidget(scrollArea)

        scrollWidget = QWidget()
        scrollArea.setWidget(scrollWidget)
        gridLayout = QGridLayout(scrollWidget)    # 网格布局

        # 从QEasingCurve获取所有的type
        curve_types = [(n, c) for n, c in QEasingCurve.__dict__.items()
            if isinstance(c, QEasingCurve.Type)]
        curve_types.sort(key = lambda ct: ct[1])
        i = 0
        for curve_name, curve_type in curve_types:
            index = curve_type % 4
            widget = QWidget()
            widget.setObjectName("_BorderWidget")
            widget.setStyleSheet("QWidget#_BorderWidget{border: 1px solid black;}")
            name = QLabel("QEasingCurve." + curve_name, widget)
            mpb = MetroProgressCircleBar(widget, curve_type)
            layout = QVBoxLayout(widget)
            layout.addWidget(name)
            layout.addWidget(mpb)
            gridLayout.addWidget(widget, i, index, 1, 1)
            if index == 3:
                i += 1

	def keyReleaseEvent_(self, ev):
		if ev.key() == Qt.Key_PageUp:
			self.imageviewer.prevImage_s()
		elif ev.key() == Qt.Key_PageDown:
			self.imageviewer.nextImage_s()
		else:
			QScrollArea.keyReleaseEvent(self, ev)

 def _create_translators_tab(self):
     translators = [
         (_('Catalan'), [u'Jaume Barcelo']),
         (_('German'), []),
         (_('Galician'), [u'Jesús Arias Fisteus']),
         (_('French'), []),
         (_('Portuguese'), []),
         (_('Spanish'), [u'Jesús Arias Fisteus']),
         ]
     parts = []
     for language, names in sorted(translators,
                                   key=DialogAbout._tuple_strxfrm):
         if names:
             parts.append(u'<p><b>{0}:</b></p>'.format(language))
             parts.append(u'<ul>')
             for name in names:
                 parts.append(u'<li>{0}</li>'.format(name))
             parts.append(u'</ul>')
     label = QLabel(u''.join(parts))
     label.setTextInteractionFlags((Qt.LinksAccessibleByKeyboard
                                    | Qt.LinksAccessibleByMouse
                                    | Qt.TextBrowserInteraction
                                    | Qt.TextSelectableByKeyboard
                                    | Qt.TextSelectableByMouse))
     scroll_area = QScrollArea(self.parent())
     scroll_area.setWidget(label)
     return scroll_area

    def update(self):
        for _ in range(self.layout().count()):
            self.layout().itemAt(0).widget().close()
            self.layout().takeAt(0)

        qsa = QScrollArea()
        scroll_area_widget = QWidget()
        layout = QVBoxLayout()
        scroll_area_widget.setLayout(layout)

        model = self.result.model
        cycles_per_ms = model.cycles_per_ms
        for proc in model.processors:
            proc_r = self.result.processors[proc]
            gb = QGroupBox(proc.name)
            gb_layout = QVBoxLayout()
            gb.setLayout(gb_layout)
            gb_layout.addWidget(QLabel(
                "Cxt Save count: {}".format(proc_r.context_save_count)))
            gb_layout.addWidget(QLabel(
                "Cxt Load count: {}".format(proc_r.context_load_count)))
            gb_layout.addWidget(QLabel(
                "Cxt Save overhead: {0:.4f}ms ({1:.0f} cycles)".format(
                    float(proc_r.context_save_overhead) / cycles_per_ms,
                    proc_r.context_save_overhead)))
            gb_layout.addWidget(QLabel(
                "Cxt Load overhead: {0:.4f}ms ({1:.0f} cycles)".format(
                    float(proc_r.context_load_overhead) / cycles_per_ms,
                    proc_r.context_load_overhead)))

            layout.addWidget(gb)

        qsa.setWidget(scroll_area_widget)
        self.layout().addWidget(qsa)

    def __init__(self, signalNames):
        super(MainWindow, self).__init__()

        widget = QWidget()
        self.setCentralWidget(widget)

        self.consoleView = ConsoleView()
        self.signalView = SignalView()
        buttonsWidget = QWidget()

        scroll = QScrollArea()
        scroll.setWidget(self.signalView)
        scroll.setWidgetResizable(True)

        hboxSignalButtons = QHBoxLayout()
        self.signalButtons = self.createSignalButtons(signalNames,
                                                      hboxSignalButtons)
        buttonsWidget.setLayout(hboxSignalButtons)

        splitter = QSplitter(self)
        splitter.setOrientation(Qt.Vertical)
        splitter.addWidget(scroll)
        splitter.addWidget(self.consoleView)
        vbox = QVBoxLayout()
        vbox.addWidget(buttonsWidget)
        vbox.addWidget(splitter)
        

        self.createActions()
        self.createMenu()

        widget.setLayout(vbox)
        self.setWindowTitle("kit")

    def initUI(self, complete, back):
        self.completeButtonClick = complete
        self.backButtonClick = back

        main_layout = QHBoxLayout()

        self.photo_load_button = QPushButton("Load photo")
        self.complete_button = QPushButton("Complete")
        self.back_button = QPushButton("Back")

        self.photo_load_button.clicked.connect(self.loadPhotoDialog)

        if self.completeButtonClick is not None:
            self.complete_button.clicked.connect(self.nextState)
        if self.backButtonClick is not None:
            self.back_button.clicked.connect(self.backButtonClick)

        toolbar = QToolbar()
        toolbar.addWidgetToToolbar(self.photo_load_button)
        toolbar.addWidgetToToolbar(self.complete_button)
        toolbar.addWidgetToToolbar(self.back_button)
        toolbar.addStretch(1)

        self.viewer = QViewer()
        viewer_scroll = QScrollArea()
        viewer_scroll.setWidget(self.viewer)
        viewer_scroll.setWidgetResizable(True)

        main_layout.addWidget(toolbar)
        main_layout.addWidget(viewer_scroll)
        main_layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(main_layout)

 def createDialogCenterWidget(self, formation):
   '''
   Scrolling list of editor widgets for editing StyleProperty.
   List comprises labels, and labeled editing widgets.
   But labels are indented as a tree.
   
   Canonical way: nest widget, layout, scrollarea
   '''
   formationLayout = formation.getLayout(top=True)
   viewport = QWidget()
   viewport.setLayout(formationLayout)
   
   # A hack so scroll bars not obscure buttons?
   # !!! left, top, right, bottom (not top, left... as usual.)
   viewport.setContentsMargins(10, 10, 10, 10)
   
   scrollArea = QScrollArea()
   scrollArea.setWidget(viewport)
   
   '''
   Assert width of contents is less than screen width (even mobile screens.)
   Can't assert height of contents less than screen height,
   e.g. a stylesheet has large height that must be vertically scrolled.
   Note this is statically determined, at design time,
   by ensuring that all rows are narrow.
   TODO dynamically enable horizontal and vertical scroll bar policy
   by calculations based on screen size and size of dialog needs?
   
   At one time, this not work: it obscured contents.
   Before I shortened many labels and model names???
   '''
   scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
   return scrollArea

	def createWidgets(self):
		"""Cette fonction permet la création de tous les widgets de la
		mainWindow"""
		
		#Création toolbar
		toolBar = self.addToolBar("Tools")
		
		#Création bar recherche
		self.lineEditSearch = QLineEdit()
		self.lineEditSearch.setPlaceholderText("Recherche")
		self.lineEditSearch.setStyleSheet("background-color:white")
		toolBar.addWidget(self.lineEditSearch)
		self.lineEditSearch.setMaximumWidth(300)
		
		#Création séparateur
		toolBar.addSeparator()
		
		#Création icon add contact
		self.actionAdd = QAction("Ajouter (Ctrl+P)",self)
		toolBar.addAction(self.actionAdd)
		self.actionAdd.setShortcut("Ctrl+P")
		self.actionAdd.setIcon(QIcon("Pictures/sign.png"))
		
		#Création icon delete contact
		self.actionDelete = QAction("supprimer (Ctrl+D)",self)
		toolBar.addAction(self.actionDelete)	
		self.actionDelete.setShortcut("Ctrl+D")
		self.actionDelete.setIcon(QIcon("Pictures/contacts.png"))
		
		#Création icon quit
		self.actionQuitter = QAction("Quitter (Ctrl+Q)",self)
		toolBar.addAction(self.actionQuitter)
		self.actionQuitter.setShortcut("Ctrl+Q")
		self.actionQuitter.setIcon(QIcon("Pictures/arrows.png"))
		
		#Création widget central
		self.centralWidget = QWidget()
		self.centralWidget.setStyleSheet("background-color:white")
		self.setCentralWidget(self.centralWidget)
		
		
		#Création dockWidget left
		dockDisplay = QDockWidget("Répertoire")
		dockDisplay.setStyleSheet("background-color:white")
		dockDisplay.setFeatures(QDockWidget.DockWidgetFloatable)
		dockDisplay.setAllowedAreas(Qt.LeftDockWidgetArea | 
			Qt.RightDockWidgetArea)
		self.addDockWidget(Qt.LeftDockWidgetArea,dockDisplay)
		containDock = QWidget(dockDisplay)
		dockDisplay.setWidget(containDock)
		dockLayout = QVBoxLayout()
		displayWidget = QScrollArea()
		displayWidget.setWidgetResizable(1)
		dockLayout.addWidget(displayWidget)
		containDock.setLayout(dockLayout)
		
		#Ajouter la list au dockwidget
		self.listContact = QListWidget()
		displayWidget.setWidget(self.listContact)

    def __init__(self, parent = None, direction = "ltr", rtf = False):
        """ Creates a new QPageWidget on given parent object. 

        parent: QWidget parent
        direction: "ltr" -> Left To Right
                   "ttb" -> Top To Bottom
        rtf: Return to first, if its True it flips to the first page 
             when next page requested at the last page
        """
        # First initialize, QPageWidget is based on QScrollArea
        QScrollArea.__init__(self, parent)

        # Properties for QScrollArea
        self.setFrameShape(QFrame.NoFrame)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setWidgetResizable(True)

        # Main widget, which stores all Pages in it
        self.widget = QWidget(self)

        # Layout based on QBoxLayout which supports Vertical or Horizontal layout
        if direction == "ltr":
            self.layout = QBoxLayout(QBoxLayout.LeftToRight, self.widget)
            self.__scrollBar = self.horizontalScrollBar()
            self.__base_value = self.width
        else:
            self.layout = QBoxLayout(QBoxLayout.TopToBottom, self.widget)
            self.__scrollBar = self.verticalScrollBar()
            self.__base_value = self.height
        self.layout.setSpacing(0)
        self.layout.setMargin(0)

        # Return to first
        self.__return_to_first = rtf

        # TMP_PAGE, its using as last page in stack
        # A workaround for a QScrollArea bug
        self.__tmp_page = Page(QWidget(self.widget))
        self.__pages = [self.__tmp_page]
        self.__current = 0
        self.__last = 0

        # Set main widget
        self.setWidget(self.widget)

        # Animation TimeLine
        self.__timeline = QTimeLine()
        self.__timeline.setUpdateInterval(2)

        # Updates scrollbar position when frame changed
        self.__timeline.frameChanged.connect(lambda x: self.__scrollBar.setValue(x))

        # End of the animation
        self.__timeline.finished.connect(self._animateFinished)

        # Initialize animation
        self.setAnimation()
        self.setDuration()

class Win(QMainWindow):
    def __init__(self, parent=None):
        super(Win, self).__init__(parent)
        self.player = None
        # args
        parser = argparse.ArgumentParser(description='BBC radio player')
        parser.add_argument('-p', '--player', default='vlc')
        parser.add_argument('player_args', nargs='*')
        args = parser.parse_args()
        self.player_prog = args.player
        self.player_args = args.player_args
        # UI
        self.setWindowTitle(WIN_TITLE)
        self.setMinimumSize(300, 600)
        self.scroll_area = QScrollArea()
        self.widget = QWidget()
        self.layout = QVBoxLayout()
        self.widget.setLayout(self.layout)
        self.scroll_area.setWidgetResizable(True)
        self.scroll_area.setWidget(self.widget)
        self.setCentralWidget(self.scroll_area)
        for name, url in STATIONS:
            button = QPushButton(name.replace('&', '&&'))
            button.args = {
                'name': name,
                'url': url,
            }
            button.clicked.connect(self.listen)
            self.layout.addWidget(button)
        # timer
        self.timer = QTimer()
        self.timer.timeout.connect(self.check_player)

    def listen(self):
        pressed_button = self.sender()
        for button in self.widget.findChildren(QPushButton):
            if button != pressed_button and not button.isEnabled():
                button.setEnabled(True)
                break
        pressed_button.setEnabled(False)
        # stop the running player instance before starting another one
        if self.player:
            if self.player.poll() is None:
                self.player.terminate()
                self.player.wait()
        cmd = [self.player_prog]
        cmd.extend(self.player_args)
        cmd.append(pressed_button.args['url'])
        try:
            self.player = subprocess.Popen(cmd)
        except Exception, e:
            msg_box = QMessageBox()
            msg_box.setText('Couldn\'t launch\n"%s"' % ' '.join(cmd))
            msg_box.setInformativeText(unicode(e))
            msg_box.exec_()
            pressed_button.setEnabled(True)
        self.setWindowTitle('%s - %s' % (pressed_button.args['name'], WIN_TITLE))
        self.timer.start(200)

 def __init__(self, dialog):
     super(ScrolledPage, self).__init__(dialog)
     layout = QVBoxLayout(margin=0, spacing=0)
     self.setLayout(layout)
     scrollarea = QScrollArea(frameWidth=0, frameShape=QScrollArea.NoFrame)
     layout.addWidget(scrollarea)
     self.scrolledWidget = QWidget(scrollarea)
     scrollarea.setWidget(self.scrolledWidget)
     scrollarea.setWidgetResizable(True)

 def widgetFrame(self):
     """Create main display widget.
     """
     vbox = QVBoxLayout()
     scroll = QScrollArea()
     scroll.setAlignment(QtCore.Qt.AlignCenter)
     self.mediaLabel = QLabel(self)
     scroll.setWidget(self.mediaLabel)
     vbox.addWidget(scroll)
     return vbox

 def __init__(self, clearMouseOver, parent = None):
    QScrollArea.__init__(self, parent)
    self.clearMouseOver = clearMouseOver
    self.mouseOver = False
    
    self.widget = QWidget() # Just adding the layout directly doesn't work right, so wrap it in a QWidget
    self.setWidget(self.widget)
    self.setWidgetResizable(True)
    self.setMouseTracking(True)
    self.createLayout()