Python QGroupBox.setTitle方法代码示例

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def buildGui(self):
        layout = QFormLayout(self)
        self.is_default = False
        self.setTitle(tr("Route specification"))
        self.setSubTitle(tr("Specify a route"))

        self.network = NetworkCombo(parent=self, modelname=MODEL_NETWORKS_EXCL_HA)
        layout.addRow(tr("Network :"), self.network)

        dst_group = QGroupBox()
        layout.addRow(dst_group)
        dst_group.setTitle(tr("Route parameters"))
        form = QGridLayout(dst_group)

        self.destination = NetworkEdit()
        self.gateway = IpEdit()

        self.registerField("destination", self.destination)
        form.addWidget(QLabel(tr("Destination")), 0, 0)
        form.addWidget(self.destination, 0, 1)
        self.connect(self.gateway, SIGNAL('textChanged(QString)'), self.ifCompleteChanged)
        self.connect(self.destination, SIGNAL('textChanged(QString)'), self.ifCompleteChanged)

        build_default = QPushButton(tr("Build a default route"))
        form.addWidget(build_default, 0, 2)
        self.connect(build_default, SIGNAL('clicked()'), self.setDefaultRoute)

        self.registerField("gateway", self.gateway)
        form.addWidget(QLabel(tr("Gateway")), 2, 0)
        form.addWidget(self.gateway, 2, 1)

        self.message = Help()

        form.addWidget(self.message, 3, 0, 1, 3)

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def __getDebugGroupbox( self ):
        " Creates the debug settings groupbox "
        dbgGroupbox = QGroupBox( self )
        dbgGroupbox.setTitle( "Debugger" )
        sizePolicy = QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred )
        sizePolicy.setHorizontalStretch( 0 )
        sizePolicy.setVerticalStretch( 0 )
        sizePolicy.setHeightForWidth(
                    dbgGroupbox.sizePolicy().hasHeightForWidth() )
        dbgGroupbox.setSizePolicy( sizePolicy )

        dbgLayout = QVBoxLayout( dbgGroupbox )
        self.__reportExceptionCheckBox = QCheckBox( "Report &exceptions" )
        self.__reportExceptionCheckBox.stateChanged.connect(
                                            self.__onReportExceptionChanged )
        self.__traceInterpreterCheckBox = QCheckBox( "T&race interpreter libs" )
        self.__traceInterpreterCheckBox.stateChanged.connect(
                                            self.__onTraceInterpreterChanged )
        self.__stopAtFirstCheckBox = QCheckBox( "Stop at first &line" )
        self.__stopAtFirstCheckBox.stateChanged.connect(
                                            self.__onStopAtFirstChanged )
        self.__autoforkCheckBox = QCheckBox( "&Fork without asking" )
        self.__autoforkCheckBox.stateChanged.connect(self.__onAutoforkChanged )
        self.__debugChildCheckBox = QCheckBox( "Debu&g child process" )
        self.__debugChildCheckBox.stateChanged.connect( self.__onDebugChild )

        dbgLayout.addWidget( self.__reportExceptionCheckBox )
        dbgLayout.addWidget( self.__traceInterpreterCheckBox )
        dbgLayout.addWidget( self.__stopAtFirstCheckBox )
        dbgLayout.addWidget( self.__autoforkCheckBox )
        dbgLayout.addWidget( self.__debugChildCheckBox )
        return dbgGroupbox

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def __init__(self,resource_name,parent=None):
        super().__init__(parent)
        self.inst = HP54616B(resource_name)
        self.inst.initialize()

        self.timer = QTimer(self)
        self.timer.setSingleShot(True)
        self.timer.timeout.connect(self.refresh)

        self.ui = Ui_main_window()
        self.ui.setupUi(self)
        connect_driver(self,self.inst)
        self.channelControls = []
        for channel in self.inst.channels:
            chan = QGroupBox()
            self.channelControls.append(chan)
            chan.n = channel
            chan_ui = Ui_channel_controls()
            chan_ui.setupUi(chan)
            chan.setTitle('Channel {:d}'.format(channel))
            connect_feat(chan_ui.range, self.inst, 'range', channel)
            connect_feat(chan_ui.offset, self.inst, 'offset', channel)
            connect_feat(chan_ui.visible, self.inst, 'visible', channel)
            self.ui.controlBox.addWidget(chan)

        self.figure = Figure()
        self.figureCanvas = FigureCanvasQTAgg(self.figure)
        self.ui.plotBox.addWidget(self.figureCanvas)
        self.axes = self.figure.add_subplot(111)
        self.ui.plot.clicked.connect(self.refresh)
        self.ui.save.clicked.connect(self.save)
        self.ui.checkMosaic.stateChanged.connect(self.setMosaic)
        self.ui.refreshAuto.clicked.connect(self.refreshConfig)
        self.plotDelay = self.findChild((QWidget,),'refreshDelay')
        self.mosaic = False

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def buildAntispam(self, layout, row, col):
        antispam = QGroupBox(self)
        antispam.setTitle(tr('Antispam'))
        antispam_layout = QFormLayout(antispam)
        antispam_enable = QCheckBox()
        info = QLabel(tr("This will add an <code>X-Spam-Score:</code> header "
            "field to all the messages and add a <code>Subject:</code> line "
            "beginning with *<i>SPAM</i>* and containing the original subject "
            "to the messages detected as spam."))
        info.setWordWrap(True)
        antispam_layout.addRow(info)
        antispam_layout.addRow(tr('Activate the antispam'), antispam_enable)
        mark_spam_level = QDoubleSpinBox(self)
        mark_spam_level.setDecimals(1)
        antispam_layout.addRow(tr('Mark the message as spam if its score is greater than'), mark_spam_level)
        deny_spam_level = QDoubleSpinBox(self)
        deny_spam_level.setDecimals(1)
        antispam_layout.addRow(tr('Refuse the message if its score is greater than'), deny_spam_level)

        # enable/disable spam levels
        self.connect(antispam_enable, SIGNAL('toggled(bool)'), mark_spam_level.setEnabled)
        self.connect(antispam_enable, SIGNAL('toggled(bool)'), deny_spam_level.setEnabled)

        # update config
        self.connect(mark_spam_level, SIGNAL('valueChanged(double)'), self.setMarkSpamLevel)
        self.connect(deny_spam_level, SIGNAL('valueChanged(double)'), self.setDenySpamLevel)
        self.connect(antispam_enable, SIGNAL('clicked(bool)'), self.setAntispamEnabled)

        layout.addWidget(antispam, row, col)

        self.mainwindow.writeAccessNeeded(mark_spam_level, deny_spam_level)

        return antispam_enable, mark_spam_level, deny_spam_level

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def __getProfileLimitsGroupbox( self ):
        " Creates the profile limits groupbox "
        limitsGroupbox = QGroupBox( self )
        limitsGroupbox.setTitle( "Profiler diagram limits" )
        sizePolicy = QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred )
        sizePolicy.setHorizontalStretch( 0 )
        sizePolicy.setVerticalStretch( 0 )
        sizePolicy.setHeightForWidth(
                limitsGroupbox.sizePolicy().hasHeightForWidth() )
        limitsGroupbox.setSizePolicy( sizePolicy )

        layoutLimits = QGridLayout( limitsGroupbox )
        self.__nodeLimitEdit = QLineEdit()
        self.__nodeLimitEdit.textEdited.connect( self.__setRunButtonProps )
        self.__nodeLimitValidator = QDoubleValidator( 0.0, 100.0, 2, self )
        self.__nodeLimitValidator.setNotation( QDoubleValidator.StandardNotation )
        self.__nodeLimitEdit.setValidator( self.__nodeLimitValidator )
        nodeLimitLabel = QLabel( "Hide nodes below" )
        self.__edgeLimitEdit = QLineEdit()
        self.__edgeLimitEdit.textEdited.connect( self.__setRunButtonProps )
        self.__edgeLimitValidator = QDoubleValidator( 0.0, 100.0, 2, self )
        self.__edgeLimitValidator.setNotation( QDoubleValidator.StandardNotation )
        self.__edgeLimitEdit.setValidator( self.__edgeLimitValidator )
        edgeLimitLabel = QLabel( "Hide edges below" )
        layoutLimits.addWidget( nodeLimitLabel, 0, 0 )
        layoutLimits.addWidget( self.__nodeLimitEdit, 0, 1 )
        layoutLimits.addWidget( QLabel( "%" ), 0, 2 )
        layoutLimits.addWidget( edgeLimitLabel, 1, 0 )
        layoutLimits.addWidget( self.__edgeLimitEdit, 1, 1 )
        layoutLimits.addWidget( QLabel( "%" ), 1, 2 )
        return limitsGroupbox

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def __getIDEWideGroupbox( self ):
        " Creates the IDE wide groupbox "
        ideGroupbox = QGroupBox( self )
        ideGroupbox.setTitle( "IDE Wide Settings" )
        sizePolicy = QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred )
        sizePolicy.setHorizontalStretch( 0 )
        sizePolicy.setVerticalStretch( 0 )
        sizePolicy.setHeightForWidth(
                        ideGroupbox.sizePolicy().hasHeightForWidth() )
        ideGroupbox.setSizePolicy( sizePolicy )

        layoutIDE = QHBoxLayout( ideGroupbox )

        termGroupbox = self.__getTermGroupbox()
        termGroupbox.setTitle( "Terminal to run in" )
        layoutIDE.addWidget( termGroupbox )

        if self.__action == "profile":
            # Profile version of the dialog
            limitsGroupbox = self.__getProfileLimitsGroupbox()
            layoutIDE.addWidget( limitsGroupbox )
        else:
            # Debug version of the dialog
            dbgGroupbox = self.__getDebugGroupbox()
            layoutIDE.addWidget( dbgGroupbox )
        return ideGroupbox

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
 def buildAntivirus(self, layout, row, col):
     antivirus = QGroupBox(self)
     antivirus.setTitle(tr('Antivirus'))
     antivirus_layout = QFormLayout(antivirus)
     antivirus_enable = QCheckBox()
     antivirus_layout.addRow(tr('Enable antivirus'), antivirus_enable)
     self.connect(antivirus_enable, SIGNAL('clicked(bool)'), self.setAntivirusEnabled)
     layout.addWidget(antivirus, row, col)
     return antivirus_enable

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def buildPostProcessorForm(self, theParams):
        """Build Post Processor Tab

        Args:
           * theParams - dictionary containing element of form
        Returns:
           not applicable
        """

        # create postprocessors tab
        myTab = QWidget()
        myFormLayout = QFormLayout(myTab)
        myFormLayout.setLabelAlignment(Qt.AlignLeft)
        self.tabWidget.addTab(myTab, self.tr('Postprocessors'))
        self.tabWidget.tabBar().setVisible(True)

        # create element for the tab
        myValues = {}
        for myLabel, myOptions in theParams.items():
            myInputValues = {}

            # NOTE (gigih) : 'params' is assumed as dictionary
            if 'params' in myOptions:
                myGroupBox = QGroupBox()
                myGroupBox.setCheckable(True)
                myGroupBox.setTitle(get_postprocessor_human_name(myLabel))

                # NOTE (gigih): is 'on' always exist??
                myGroupBox.setChecked(myOptions.get('on'))
                myInputValues['on'] = self.bind(myGroupBox, 'checked', bool)

                myLayout = QFormLayout(myGroupBox)
                myGroupBox.setLayout(myLayout)

                # create widget element from 'params'
                myInputValues['params'] = {}
                for myKey, myValue in myOptions['params'].items():
                    myHumanName = get_postprocessor_human_name(myKey)
                    myInputValues['params'][myKey] = self.buildWidget(
                        myLayout, myHumanName, myValue)

                myFormLayout.addRow(myGroupBox, None)

            elif 'on' in myOptions:
                myCheckBox = QCheckBox()
                myCheckBox.setText(get_postprocessor_human_name(myLabel))
                myCheckBox.setChecked(myOptions['on'])

                myInputValues['on'] = self.bind(myCheckBox, 'checked', bool)
                myFormLayout.addRow(myCheckBox, None)
            else:
                raise NotImplementedError('This case is not handled for now')

            myValues[myLabel] = myInputValues

        self.values['postprocessors'] = myValues

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
class Score(_base.Group, scoreproperties.ScoreProperties):
    @staticmethod
    def title(_=_base.translate):
        return _("Score")

    def createWidgets(self, layout):
        self.pieceLabel = QLabel()
        self.piece = QLineEdit()
        self.pieceLabel.setBuddy(self.piece)
        self.opusLabel = QLabel()
        self.opus = QLineEdit()
        self.opusLabel.setBuddy(self.opus)
        self.scoreProps = QGroupBox(checkable=True, checked=False)
        scoreproperties.ScoreProperties.createWidgets(self)
        
        grid = QGridLayout()
        grid.addWidget(self.pieceLabel, 0 ,0)
        grid.addWidget(self.piece, 0, 1)
        grid.addWidget(self.opusLabel, 1, 0)
        grid.addWidget(self.opus, 1, 1)
        layout.addLayout(grid)
        layout.addWidget(self.scoreProps)
        layout = QVBoxLayout()
        self.scoreProps.setLayout(layout)
        scoreproperties.ScoreProperties.layoutWidgets(self, layout)
        
        scorewiz = self.scoreProps.window()
        self.setPitchLanguage(scorewiz.pitchLanguage())
        scorewiz.pitchLanguageChanged.connect(self.setPitchLanguage)
        
    def translateWidgets(self):
        self.pieceLabel.setText(_("Piece:"))
        self.opusLabel.setText(_("Opus:"))
        self.scoreProps.setTitle(_("Properties"))
        scoreproperties.ScoreProperties.translateWidgets(self)
        
    def accepts(self):
        return (StaffGroup, _base.Part)

    def makeNode(self, node):
        score = ly.dom.Score(node)
        h = ly.dom.Header()
        piece = self.piece.text().strip()
        opus = self.opus.text().strip()
        if piece:
            h['piece'] = ly.dom.QuotedString(piece)
        if opus:
            h['opus'] = ly.dom.QuotedString(opus)
        if len(h):
            score.append(h)
        return score
    
    def globalSection(self, builder):
        if self.scoreProps.isChecked():
            return scoreproperties.ScoreProperties.globalSection(self, builder)

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def build_post_processor_form(self, parameters):
        """Build Post Processor Tab.

        :param parameters: A Dictionary containing element of form
        :type parameters: dict
        """
        # create postprocessors tab
        tab = QWidget()
        form_layout = QFormLayout(tab)
        form_layout.setLabelAlignment(Qt.AlignLeft)
        self.tabWidget.addTab(tab, self.tr('Postprocessors'))
        self.tabWidget.tabBar().setVisible(True)

        # create element for the tab
        values = OrderedDict()
        for label, options in parameters.items():
            input_values = OrderedDict()

            # NOTE (gigih) : 'params' is assumed as dictionary
            if 'params' in options:
                group_box = QGroupBox()
                group_box.setCheckable(True)
                group_box.setTitle(get_postprocessor_human_name(label))

                # NOTE (gigih): is 'on' always exist??
                # (MB) should always be there
                group_box.setChecked(options.get('on'))
                input_values['on'] = self.bind(group_box, 'checked', bool)

                layout = QFormLayout(group_box)
                group_box.setLayout(layout)

                # create widget element from 'params'
                input_values['params'] = OrderedDict()
                for key, value in options['params'].items():
                    input_values['params'][key] = self.build_widget(
                        layout, key, value)

                form_layout.addRow(group_box, None)

            elif 'on' in options:
                checkbox = QCheckBox()
                checkbox.setText(get_postprocessor_human_name(label))
                checkbox.setChecked(options['on'])

                input_values['on'] = self.bind(checkbox, 'checked', bool)
                form_layout.addRow(checkbox, None)
            else:
                raise NotImplementedError('This case is not handled for now')

            values[label] = input_values

        self.values['postprocessors'] = values

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
 def _parseDict(self, config, ui):
     l = QVBoxLayout()
     lst = list(config.keys())
     for k in lst:
         t = type(config[k])
         if t == type(int()):
             hbox = QHBoxLayout()
             label = QLabel(k)
             edit = QLineEdit(str(config[k]))
             val = QIntValidator(self)
             edit.setValidator(val)
             hbox.addWidget(label)
             hbox.addWidget(edit)
             l.addLayout(hbox)
             ui[k] = (edit, label, hbox, val)
         elif t == type(float()):
             hbox = QHBoxLayout()
             label = QLabel(k)
             edit = QLineEdit(str(config[k]))
             val = QDoubleValidator(self)
             edit.setValidator(val)
             hbox.addWidget(label)
             hbox.addWidget(edit)
             l.addLayout(hbox)
             ui[k] = (edit, label, hbox, val)
         elif t == type(list()):
             hbox = QHBoxLayout()
             label = QLabel(k)
             edit = QComboBox()
             i = 0
             for s in config[k][0]:
                 edit.addItem(s)
                 if i == config[k][1]:
                     edit.setCurrentIndex(i)
                 i += 1
             hbox.addWidget(label)
             hbox.addWidget(edit)
             l.addLayout(hbox)
             ui[k] = (edit, label, hbox)
         elif t == type(dict()):
             gbox = QGroupBox()
             gbox.setTitle(k)
             ui[k] = {"gbox":gbox}
             l2 = self._parseDict(config[k], ui[k])
             ui[k]["layout"] = l2
             gbox.setLayout(l2)
             l.addWidget(gbox)
     return l

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
 def buildAdminMail(self, layout, row, col):
     admin_mail = QGroupBox(self)
     admin_mail.setTitle(tr("Administrator email address"))
     admin_mail_layout = QGridLayout(admin_mail)
     admin_mail_info = QLabel(tr("Administrator email address (EdenWall will send the system alerts to this address)"))
     admin_mail_info.setWordWrap(True)
     admin_mail_edit = MailEdit()
     admin_mail_edit.setMinimumWidth(admin_mail_edit.fontMetrics().averageCharWidth() * 15)
     admin_mail_edit.setMaximumWidth(admin_mail_edit.fontMetrics().averageCharWidth() * 45)
     admin_mail_layout.addWidget(admin_mail_info, 0, 0)
     admin_mail_layout.addWidget(admin_mail_edit, 1, 0)
     admin_mail_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum) , 2, 0)
     self.connect(admin_mail_edit, SIGNAL('textEdited(QString)'), self.setAdminMail)
     layout.addWidget(admin_mail, row, col)
     self.mainwindow.writeAccessNeeded(admin_mail_info, admin_mail_edit)
     return admin_mail_edit

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
 def buildChooseLanguage(self, layout, row, col):
     language = QGroupBox(self)
     language.setTitle(tr('Language for emails'))
     language_layout = QGridLayout(language)
     language_info = QLabel(tr('Language for emails sent by EdenWall to the Administrator'))
     language_info.setWordWrap(True)
     language_choose = QComboBox()
     for name in ContactConf.CODE_TO_NAME.itervalues():
         language_choose.addItem(name)
     language_layout.addWidget(language_info, 0, 0, 1, 0)
     language_layout.addWidget(language_choose, 1, 0)
     language_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum) , 1, 1)
     self.connect(language_choose, SIGNAL('activated(QString)'), self.setLanguage)
     layout.addWidget(language, row, col)
     self.mainwindow.writeAccessNeeded(language_info, language_choose)
     return language_choose

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def buildOutgoing(self, layout, row, col):
        outgoing = QGroupBox(self)
        outgoing.setTitle(tr('Outgoing emails'))
        outgoing_layout = QGridLayout(outgoing)

        relayed_net = NetworkListEdit(self)
        relayed_net.setMaximumHeight(relayed_net.fontMetrics().height() * 5)
        self.connect(relayed_net, SIGNAL("textChanged()"), self.setMailModified)
        outgoing_layout.addWidget(QLabel(tr('Networks for which EdenWall relays emails')), 0, 0)
        outgoing_layout.addWidget(relayed_net, 1, 0, 1, 2)

        outgoing_layout.addWidget(QLabel(tr(
            """If outgoing mail should be relayed through a 'smarthost', configure this host in the "Contact" page of the "Services" tab."""
        )))

        layout.addWidget(outgoing, row, col)
        return relayed_net

# 需要导入模块: from PyQt4.QtGui import QGroupBox [as 别名]
# 或者: from PyQt4.QtGui.QGroupBox import setTitle [as 别名]
    def __init__(self, client, parent):
        ScrollArea.__init__(self)

        self.client = client
        self.mainwindow = parent
        self.form = QFormLayout(self)

        title = QLabel("<H1>Services</H1>")
        self.form.addRow(title)

        self.monitor = None
        group = QGroupBox()
        group.setTitle(self.tr("System Services Status"))
        box = QVBoxLayout(group)
        #parent is expected to be MainWindow !
        self.monitor = MonitorWindow(client, self, parent)
        box.addWidget(self.monitor)
        self.form.addRow(group)