Python QVBoxLayout.removeWidget方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class CommodityBox(QGroupBox):
    changed = pyqtSignal()

    def __init__(self, options, title="Commodities"):
        super(CommodityBox, self).__init__(title)
        self.options = options
        self.options.reset.connect(self.reset)

        self.setToolTip("Show only selected commodities")

        self.setCheckable(True)
        self.setChecked(False)
        self.toggled.connect(self.changed)

        self.layout = QVBoxLayout(self)
        self.checkboxes = {}

    def __contains__(self, commodity):
        if not self.isChecked():
            return True
        checkbox = self.checkboxes.get(commodity)
        return checkbox and checkbox.isChecked()

    def reset(self):
        for checkbox in self.checkboxes.values():
            self.layout.removeWidget(checkbox)
        self.checkboxes = {}

        commodities = self.options.journal.commodities
        for commodity in commodities.keys():
            checkbox = QCheckBox(commodity, self)
            self.checkboxes[commodity] = checkbox
            self.layout.addWidget(checkbox)
            checkbox.stateChanged.connect(self.changed)

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class MessageView(QWidget):

    """Widget which stacks error/warning/info messages."""

    update_geometry = pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)
        self._vbox = QVBoxLayout(self)
        self._vbox.setContentsMargins(0, 0, 0, 0)
        self._vbox.setSpacing(0)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)

        self._clear_timer = QTimer()
        self._clear_timer.timeout.connect(self._clear_messages)
        self._set_clear_timer_interval()
        objreg.get('config').changed.connect(self._set_clear_timer_interval)

        self._last_text = None
        self._messages = []

    def sizeHint(self):
        """Get the proposed height for the view."""
        height = sum(label.sizeHint().height() for label in self._messages)
        # The width isn't really relevant as we're expanding anyways.
        return QSize(-1, height)

    @config.change_filter('ui', 'message-timeout')
    def _set_clear_timer_interval(self):
        """Configure self._clear_timer according to the config."""
        self._clear_timer.setInterval(config.get('ui', 'message-timeout'))

    @pyqtSlot()
    def _clear_messages(self):
        """Hide and delete all messages."""
        for widget in self._messages:
            self._vbox.removeWidget(widget)
            widget.hide()
            widget.deleteLater()
        self._messages = []
        self._last_text = None
        self.hide()
        self._clear_timer.stop()

    @pyqtSlot(usertypes.MessageLevel, str)
    def show_message(self, level, text):
        """Show the given message with the given MessageLevel."""
        if text == self._last_text:
            return

        widget = Message(level, text, parent=self)
        self._vbox.addWidget(widget)
        widget.show()
        self._clear_timer.start()
        self._messages.append(widget)
        self._last_text = text
        self.show()
        self.update_geometry.emit()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class MessageView(QWidget):

    """Widget which stacks error/warning/info messages."""

    reposition = pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)
        self._vbox = QVBoxLayout(self)
        self._vbox.setContentsMargins(0, 0, 0, 0)
        self._vbox.setSpacing(0)

        self._clear_timer = QTimer()
        self._clear_timer.timeout.connect(self._clear_messages)
        self._set_clear_timer_interval()
        objreg.get('config').changed.connect(self._set_clear_timer_interval)

        self._last_text = None
        self._messages = []

    @config.change_filter('ui', 'message-timeout')
    def _set_clear_timer_interval(self):
        """Configure self._clear_timer according to the config."""
        self._clear_timer.setInterval(config.get('ui', 'message-timeout'))

    def message_height(self):
        """Get the total height of all messages."""
        return sum(label.sizeHint().height() for label in self._messages)

    @pyqtSlot()
    def _clear_messages(self):
        """Hide and delete all messages."""
        for widget in self._messages:
            self._vbox.removeWidget(widget)
            widget.hide()
            widget.deleteLater()
        self._messages = []
        self._last_text = None
        self.hide()
        self._clear_timer.stop()

    @pyqtSlot(usertypes.MessageLevel, str)
    def show_message(self, level, text):
        """Show the given message with the given MessageLevel."""
        if text == self._last_text:
            return

        widget = Message(level, text, parent=self)
        self._vbox.addWidget(widget)
        widget.show()
        self._clear_timer.start()
        self._messages.append(widget)
        self._last_text = text
        self.show()
        self.reposition.emit()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class PluginFrame(QFrame):
    def __init__(self, plugins, highlighted_plugins=None, parent=None):
        """
        :type plugins: list of Plugin
        :type highlighted_plugins: list of Plugin
        """
        super().__init__(parent)
        self.ui = Ui_FramePlugins()
        self.ui.setupUi(self)
        self.model = PluginListModel(plugins, highlighted_plugins=highlighted_plugins)
        self.ui.listViewPlugins.setModel(self.model)
        self.settings_layout = QVBoxLayout()
        self.ui.groupBoxSettings.setLayout(self.settings_layout)
        self.create_connects()

        try:
            self.restoreGeometry(constants.SETTINGS.value("{}/geometry".format(self.__class__.__name__)))
        except TypeError:
            pass


    def create_connects(self):
        self.ui.listViewPlugins.selectionModel().selectionChanged.connect(self.on_list_selection_changed)
        for plugin in self.model.plugins:
            if hasattr(plugin, "show_proto_sniff_dialog_clicked"):
                plugin.show_proto_sniff_dialog_clicked.connect(self.parent().parent().show_proto_sniff_dialog)

    def save_enabled_states(self):
        for plugin in self.model.plugins:
            constants.SETTINGS.setValue(plugin.name, plugin.enabled)

    @pyqtSlot()
    def on_list_selection_changed(self):
        i = self.ui.listViewPlugins.currentIndex().row()
        self.ui.txtEditPluginDescription.setText(self.model.plugins[i].description)

        if self.settings_layout.count() > 0:
            widget = self.settings_layout.takeAt(0).widget()
            self.settings_layout.removeWidget(widget)
            widget.setParent(None)

        self.settings_layout.addWidget(self.model.plugins[i].settings_frame)

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class Tab(QWidget):
    def __init__(self, parent):
        super(Tab, self).__init__()
        self.parent = parent
        self.list = []
        self.button_add_graph = QPushButton("Add Graph")
        self.button_add_graph.clicked.connect(partial(self.addGraph))

        self.layout = QVBoxLayout()
        self.layout.addWidget(self.button_add_graph)
        self.setLayout(self.layout)

    def addGraph(self):
        self.parent.readCfg(self.parent.config_path, last=False)
        self.layout.addWidget(PlotWindow(self))
        self.layout.addWidget(self.button_add_graph)

    def delGraph(self, widget):
        widget.close()
        self.layout.removeWidget(widget)

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class ContentView(QWidget):
    """
    Represents a generic container for holding views in ACES.
    """
    def __init__(self, parent=None):
        """
        Initializes the ContentView instance.
        :param parent: The Qt parent of the content view.
        """
        QWidget.__init__(self, parent)
        self.setObjectName("ContentView")
        self.content = None
        self.layout = QVBoxLayout()
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(self.layout)
        self.setContentsMargins(0, 0, 0, 0)
        
    def get_content(self):
        """
        Retrieves the content of the view.
        :returns: The widget that was set as the content of the content view.
        """
        return self.content
    
    def set_content(self, content):
        """
        Sets the content of the view.
        :param content: The widget that will be set as the content of the view.
        """
        # remove the existing content
        if self.content is not None:
            self.layout.removeWidget(self.content)
            self.content.setParent(None)
        
        # add the new content
        self.content = content
        
        if self.content is not None:
            self.layout.addWidget(self.content)

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class Tab(QWidget):
    def __init__(self, tabwidget):
        QWidget.__init__(self)
        self.tabwidget = tabwidget
        self.list = []
        self.button_add_graph = QPushButton("Add Graph")
        self.button_add_graph.clicked.connect(partial(self.addGraph))

        self.layout = QVBoxLayout()
        self.layout.addWidget(self.button_add_graph)
        self.plotWindow = self.addGraph()
        self.setLayout(self.layout)

    @property
    def mainwindow(self):
        return self.tabwidget.mainwindow

    def addGraph(self):
        widget = PlotWindow(self)
        self.layout.addWidget(widget)
        self.button_add_graph.hide()
        return widget

    def removeGraph(self, widget):
        widget.close()
        self.layout.removeWidget(widget)
        self.button_add_graph.show()

    def restart(self):
        for curve in self.plotWindow.curveList:
            if curve.watcher and not curve.watcher.isActive():
                curve.restart()

    def stop(self):
        for curve in self.plotWindow.curveList:
            if curve.watcher and curve.watcher.isActive():
                curve.stop()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]

#.........这里部分代码省略.........
        else:
            self._set_default_geometry()
        log.init.debug("Initial main window geometry: {}".format(
            self.geometry()))

        self._connect_signals()

        # When we're here the statusbar might not even really exist yet, so
        # resizing will fail. Therefore, we use singleShot QTimers to make sure
        # we defer this until everything else is initialized.
        QTimer.singleShot(0, self._connect_resize_completion)
        objreg.get('config').changed.connect(self.on_config_changed)

        if config.get('ui', 'hide-mouse-cursor'):
            self.setCursor(Qt.BlankCursor)

        objreg.get("app").new_window.emit(self)

    def __repr__(self):
        return utils.get_repr(self)

    @pyqtSlot(str, str)
    def on_config_changed(self, section, option):
        """Resize the completion if related config options changed."""
        if section == 'completion' and option in ('height', 'shrink'):
            self.resize_completion()
        elif section == 'ui' and option == 'statusbar-padding':
            self.resize_completion()
        elif section == 'ui' and option == 'downloads-position':
            self._add_widgets()

    def _add_widgets(self):
        """Add or readd all widgets to the VBox."""
        self._vbox.removeWidget(self.tabbed_browser)
        self._vbox.removeWidget(self._downloadview)
        self._vbox.removeWidget(self.status)
        position = config.get('ui', 'downloads-position')
        if position == 'top':
            self._vbox.addWidget(self._downloadview)
            self._vbox.addWidget(self.tabbed_browser)
        elif position == 'bottom':
            self._vbox.addWidget(self.tabbed_browser)
            self._vbox.addWidget(self._downloadview)
        else:
            raise ValueError("Invalid position {}!".format(position))
        self._vbox.addWidget(self.status)

    def _load_state_geometry(self):
        """Load the geometry from the state file."""
        state_config = objreg.get('state-config')
        try:
            data = state_config['geometry']['mainwindow']
            geom = base64.b64decode(data, validate=True)
        except KeyError:
            # First start
            self._set_default_geometry()
        except binascii.Error:
            log.init.exception("Error while reading geometry")
            self._set_default_geometry()
        else:
            self._load_geometry(geom)

    def _save_geometry(self):
        """Save the window geometry to the state config."""
        state_config = objreg.get('state-config')
        data = bytes(self.saveGeometry())

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class PlotWindow(QWidget):
    def __init__(self, tab):
        super(PlotWindow, self).__init__()
        self.tab = tab
        self.allAxes = {}
        self.curveList = []
        self.extraLines = []
        self.layout = QHBoxLayout()
        self.graph_layout = QVBoxLayout()
        self.gbox_layout = QVBoxLayout()

        self.tabGBActor = QTabWidget()

        self.dateplot = DatePlot(self)
        self.customize = Customize(self)
        self.button_arrow = self.ButtonArrow()
        self.button_del_graph = self.ButtonDelete()

        self.gbox_layout.addWidget(self.dateplot)
        self.gbox_layout.addWidget(self.customize)
        self.gbox_layout.addWidget(self.tabGBActor)
        self.gbox_layout.addWidget(self.button_del_graph)

        self.layout.addLayout(self.graph_layout)
        self.layout.addWidget(self.button_arrow)
        self.layout.addLayout(self.gbox_layout)

        for widget in [self.dateplot, self.customize, self.tabGBActor]:
            widget.setMaximumWidth(400)

        self.setLayout(self.layout)

    @property
    def mainwindow(self):
        return self.tab.mainwindow

    @property
    def config(self):
        return self.dateplot.config

    @property
    def axes2curves(self):
        d = {ax: [] for ax in [None] + list(self.allAxes.values())}

        for curve in self.curveList:
            d[curve.getAxes()].append(curve)

        return d

    @property
    def line2Curve(self):
        return {curve.line: curve for curve in self.curveList}

    @property
    def axes2id(self):
        d = {ax: id for id, ax in self.allAxes.items()}
        d[None] = None
        return d

    def createGraph(self, custom):
        try:
            self.graph.close()
            self.graph_layout.removeWidget(self.graph)
            self.graph.deleteLater()
        except AttributeError:
            pass

        self.graph = Graph(self, custom)
        self.graph_layout.insertWidget(0, self.graph)

    def getAxes(self, newType, i=-1):

        for i, ax in self.allAxes.items():
            try:
                curve = self.axes2curves[ax][0]
                if curve.type == newType:
                    return ax
            except IndexError:
                return ax

            if i == 3:
                raise ValueError('No Axe available')
        return i + 1

    def setAxes(self, allAxes):
        for idAxes, oldAxes in list(self.allAxes.items()):
            self.unsetLines(oldAxes, allAxes)
            self.allAxes.pop(idAxes, None)

        self.allAxes = allAxes

    def unsetLines(self, axes, newAxes):
        while axes.lines:
            line = axes.lines[0]
            axes.lines.remove(line)
            try:
                curve = self.line2Curve[line]
                curve.line = False
                if curve.getAxes() not in newAxes.values():
                    curve.setAxes(None)
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class NewGameWidget(Tab):
    def __init__(self, parent=None):
        super(NewGameWidget, self).__init__(parent)
        self.parent = parent
        self.initUI()

    def initUI(self):

        # Setup Layouts
        self.widgetLayout = QHBoxLayout(self)
        self.leftColumnLayout = QVBoxLayout()
        self.rightColumnLayout = QVBoxLayout()
        self.widgetLayout.addLayout(self.leftColumnLayout)
        self.widgetLayout.addLayout(self.rightColumnLayout)

        self.gameStatsBox = None

        # Players GroupBox
        self.playersGroupBox = QGroupBox(self)
        self.rightColumnLayout.addWidget(self.playersGroupBox)
        self.widgetLayout.setStretchFactor(self.rightColumnLayout, 1)
        self.populatePlayersGroupBox()

        # Game GroupBox
        self.gameGroupBox = QGroupBox(self)
        self.leftColumnLayout.addWidget(self.gameGroupBox)
        self.widgetLayout.setStretchFactor(self.leftColumnLayout, 3)
        self.populateGamesGroupBox()

#        self.retranslateUI()

    def retranslateUI(self):
        self.gameGroupBox.setTitle(
            i18n("NewGameWidget", "Games"))
        self.updateGameInfo()
        self.playersGroupBox.setTitle(
            i18n("NewGameWidget", "Players"))
        self.availablePlayersGroup.setTitle(
            i18n("NewGameWidget", "Available Players"))
        self.newPlayerButton.setText(
            i18n("NewGameWidget", "New Player"))
        self.inGameGroup.setTitle(i18n(
            "NewGameWidget", "Selected Players"))
        self.startGameButton.setText(
            i18n("NewGameWidget", "Play!"))
        self.resumeGroup.retranslateUI()
        self.gameStatsBox.retranslateUI()

    def populateGamesGroupBox(self):

        self.gameGroupBoxLayout = QVBoxLayout(self.gameGroupBox)
        self.gameComboBox = QComboBox(self.gameGroupBox)
        self.gameGroupBoxLayout.addWidget(self.gameComboBox)
        self.gameDescriptionLabel = QLabel(self.gameGroupBox)
        self.resumeGroup = ResumeBox(self.parent)
        self.resumeGroup.restartRequested.connect(self.restartGame)
#        self.gameRulesBrowser = QTextBrowser(self.gameGroupBox)
        self.gameGroupBoxLayout.addWidget(self.gameDescriptionLabel)
        self.gameGroupBoxLayout.addWidget(self.resumeGroup)
#        self.gameGroupBoxLayout.addWidget(self.gameRulesBrowser)

#        self.gameGroupBoxLayout.addStretch()

        self.games = db.getAvailableGames()
        for game in sorted(self.games.keys()):
            self.gameComboBox.addItem(game)
        lastgame = db.getLastGame()
        if lastgame:
            self.gameComboBox.setCurrentIndex(
                self.gameComboBox.findText(lastgame))

        self.gameStatsBox = None

#        self.updateGameInfo()

        self.gameComboBox.currentIndexChanged.connect(self.updateGameInfo)

    def updateGameInfo(self, foo=0):

        game = str(self.gameComboBox.currentText())
        description = "2 - {} {}\n\n{}".format(
            self.games[game]['maxPlayers'],
            i18n("NewGameWidget", 'players'),
            self.games[game]['description'])
        self.gameDescriptionLabel.setText(description)
#        self.gameRulesBrowser.setText("{}".format(self.games[game]['rules']))
#         self.gameStatsBox.update(game)
        if self.gameStatsBox is not None:
            self.gameGroupBoxLayout.removeWidget(self.gameStatsBox)
            # print("UGI deleting")
            self.gameStatsBox.deleteLater()

        self.gameStatsBox = QSFactory.createQS(game, None, self)
        self.gameGroupBoxLayout.addWidget(self.gameStatsBox)
        self.updateStats()
        self.resumeGroup.changeGame(game)

    def updateStats(self):
        if self.gameStatsBox:
            try:
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class MessageView(QWidget):

    """Widget which stacks error/warning/info messages."""

    update_geometry = pyqtSignal()

    def __init__(self, parent=None):
        super().__init__(parent)
        self._messages = []
        self._vbox = QVBoxLayout(self)
        self._vbox.setContentsMargins(0, 0, 0, 0)
        self._vbox.setSpacing(0)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)

        self._clear_timer = QTimer()
        self._clear_timer.timeout.connect(self.clear_messages)
        config.instance.changed.connect(self._set_clear_timer_interval)

        self._last_text = None

    def sizeHint(self):
        """Get the proposed height for the view."""
        height = sum(label.sizeHint().height() for label in self._messages)
        # The width isn't really relevant as we're expanding anyways.
        return QSize(-1, height)

    @config.change_filter('messages.timeout')
    def _set_clear_timer_interval(self):
        """Configure self._clear_timer according to the config."""
        interval = config.val.messages.timeout
        if interval > 0:
            interval *= min(5, len(self._messages))
            self._clear_timer.setInterval(interval)

    @pyqtSlot()
    def clear_messages(self):
        """Hide and delete all messages."""
        for widget in self._messages:
            self._vbox.removeWidget(widget)
            widget.hide()
            widget.deleteLater()
        self._messages = []
        self._last_text = None
        self.hide()
        self._clear_timer.stop()

    @pyqtSlot(usertypes.MessageLevel, str, bool)
    def show_message(self, level, text, replace=False):
        """Show the given message with the given MessageLevel."""
        if text == self._last_text:
            return

        if replace and self._messages and self._messages[-1].replace:
            old = self._messages.pop()
            old.hide()

        widget = Message(level, text, replace=replace, parent=self)
        self._vbox.addWidget(widget)
        widget.show()
        self._messages.append(widget)
        self._last_text = text
        self.show()
        self.update_geometry.emit()
        if config.val.messages.timeout != 0:
            self._set_clear_timer_interval()
            self._clear_timer.start()

    def mousePressEvent(self, e):
        """Clear messages when they are clicked on."""
        if e.button() in [Qt.LeftButton, Qt.MiddleButton, Qt.RightButton]:
            self.clear_messages()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class Radiobutton(vip_base):
    def cb_initialize_plugin(self):

        self.event_choice = DEvent("Choice")

        self.pl_send_new_event_list([self.event_choice])

        self.config = self.pl_get_current_config_ref()
        para_list = []

        self.para_texts = DParameter("texts", default=self.config["option_texts"]["value"])
        self.para_values = DParameter("values", default=self.config["option_values"]["value"])

        para_list.append(self.para_texts)
        para_list.append(self.para_values)

        self.pl_send_new_parameter_list(para_list)

        self.central_widget = QWidget()

        self.option_texts = []
        self.option_values = []
        self.pre_selected_index = None

        if isinstance(self.config["selected_index"]["value"], str):
            if self.config["selected_index"]["value"] != "":
                self.pre_selected_index = int(self.config["selected_index"]["value"])

        self.pl_set_widget_for_internal_usage(self.central_widget)
        self.layout = QVBoxLayout(self.central_widget)

        self.buttons = []

        self.set_option_texts(self.config["option_texts"]["value"])
        self.set_option_values(self.config["option_values"]["value"])

        self.update_widget()

        return True

    def set_option_values(self, values):

        if isinstance(values, str):
            self.option_values = str.split(values, ",")

            for i in range(len(self.option_values)):
                self.option_values[i] = self.option_values[i].lstrip().rstrip()

    def set_option_texts(self, texts):

        if isinstance(texts, str):
            self.option_texts = str.split(texts, ",")

            for i in range(len(self.option_texts)):
                self.option_texts[i] = self.option_texts[i].lstrip().rstrip()

    def update_widget(self):

        for button in self.buttons:
            self.layout.removeWidget(button)
            button.deleteLater()

        self.buttons = []

        for i in range(len(self.option_texts)):
            button = QRadioButton(self.option_texts[i])

            button.released.connect(self.button_released)

            if i == self.pre_selected_index:
                button.setChecked(True)

            self.buttons.append(button)
            self.layout.addWidget(button)

        self.central_widget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.central_widget.customContextMenuRequested.connect(self.show_context_menu)

        return self.central_widget

    def show_context_menu(self, pos):
        gloPos = self.central_widget.mapToGlobal(pos)
        self.cmenu = self.pl_create_control_context_menu()
        self.cmenu.exec_(gloPos)

    def button_released(self):
        for i in range(len(self.buttons)):
            if self.buttons[i].isChecked():
                self.config["selected_index"]["value"] = str(i)
                if len(self.option_values) == len(self.option_texts):
                    self.pl_emit_event(self.option_values[i], self.event_choice)
                else:
                    self.pl_emit_event(self.option_texts[i], self.event_choice)

    def cb_set_parameter(self, parameter_name, parameter_value):

        if parameter_name == self.para_texts.name:
            self.config["option_texts"]["value"] = parameter_value
            self.set_option_texts(parameter_value)
            self.update_widget()
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class Ui(QWidget):
	def __init__(self, socman):
		super(Ui, self).__init__()

		# create objects;

		self.__ob_vlay_main = QVBoxLayout()

		self.__ob_widget_menu = MenuUI()
		self.__ob_widget_add = AddUI(socman)
		self.__ob_widget_list = ListUI(socman)
		self.__ob_widget_about = AboutUI()

		# config;

		self.setLayout(self.__ob_vlay_main)
		self.setFixedSize(800,600)
		self.setWindowTitle("Социлогия: основные понятия и др.")

		self.__ob_widget_menu.buttonClicked = self.__onMenuClicked

		self.__ob_widget_add.buttonClicked = self.__onAddClicked

		self.__ob_widget_list.buttonClicked = self.__onListClicked
		self.__ob_widget_list.doubleClicked = self.__onDoubleClicked

		self.__ob_widget_about.buttonClicked = self.__onAboutClicked

		self.__ob_vlay_main.addWidget(self.__ob_widget_menu)
		self.__ob_vlay_main.setAlignment(Qt.AlignCenter)
		self.__ob_vlay_main.setContentsMargins(0, 0, 0, 0)

	def __onMenuClicked(self, text):
		if(text == "<p align='center'>Добавить"):
			self.__ob_widget_menu.hide()
			self.__ob_vlay_main.removeWidget(self.__ob_widget_menu)
			self.__ob_vlay_main.addWidget(self.__ob_widget_add)
			self.__ob_widget_add.show()
		elif(text == "<p align='center'>Список"):
			self.__ob_widget_menu.hide()
			self.__ob_vlay_main.removeWidget(self.__ob_widget_menu)
			self.__ob_vlay_main.addWidget(self.__ob_widget_list)
			self.__ob_widget_list.showData()

	def __onAddClicked(self):
		self.__ob_widget_add.hide()
		self.__ob_vlay_main.removeWidget(self.__ob_widget_add)
		self.__ob_vlay_main.addWidget(self.__ob_widget_menu)
		self.__ob_widget_menu.show()

	def __onListClicked(self):
		self.__ob_widget_list.hide()
		self.__ob_vlay_main.removeWidget(self.__ob_widget_list)
		self.__ob_vlay_main.addWidget(self.__ob_widget_menu)
		self.__ob_widget_menu.show()

	def __onDoubleClicked(self, item):
		self.__ob_widget_list.hide()
		self.__ob_vlay_main.removeWidget(self.__ob_widget_list)
		self.__ob_vlay_main.addWidget(self.__ob_widget_about)
		self.__ob_widget_about.showData(item)

	def __onAboutClicked(self):
		self.__ob_widget_about.hide()
		self.__ob_vlay_main.removeWidget(self.__ob_widget_about)
		self.__ob_vlay_main.addWidget(self.__ob_widget_list)
		self.__ob_widget_list.showData()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]

#.........这里部分代码省略.........
        self._completion.selection_changed.connect(
            completer_obj.on_selection_changed)
        objreg.register('completion', self._completion, scope='window',
                        window=self.win_id)
        self._add_overlay(self._completion, self._completion.update_geometry)

    def _init_command_dispatcher(self):
        dispatcher = commands.CommandDispatcher(self.win_id,
                                                self.tabbed_browser)
        objreg.register('command-dispatcher', dispatcher, scope='window',
                        window=self.win_id)
        self.tabbed_browser.destroyed.connect(
            functools.partial(objreg.delete, 'command-dispatcher',
                              scope='window', window=self.win_id))

    def __repr__(self):
        return utils.get_repr(self)

    @pyqtSlot(str, str)
    def on_config_changed(self, section, option):
        """Resize the completion if related config options changed."""
        if section != 'ui':
            return
        if option == 'statusbar-padding':
            self._update_overlay_geometries()
        elif option == 'downloads-position':
            self._add_widgets()
        elif option == 'status-position':
            self._add_widgets()
            self._update_overlay_geometries()

    def _add_widgets(self):
        """Add or readd all widgets to the VBox."""
        self._vbox.removeWidget(self.tabbed_browser)
        self._vbox.removeWidget(self._downloadview)
        self._vbox.removeWidget(self.status)
        downloads_position = config.get('ui', 'downloads-position')
        status_position = config.get('ui', 'status-position')
        widgets = [self.tabbed_browser]

        if downloads_position == 'top':
            widgets.insert(0, self._downloadview)
        elif downloads_position == 'bottom':
            widgets.append(self._downloadview)
        else:
            raise ValueError("Invalid position {}!".format(downloads_position))

        if status_position == 'top':
            widgets.insert(0, self.status)
        elif status_position == 'bottom':
            widgets.append(self.status)
        else:
            raise ValueError("Invalid position {}!".format(status_position))

        for widget in widgets:
            self._vbox.addWidget(widget)

    def _load_state_geometry(self):
        """Load the geometry from the state file."""
        state_config = objreg.get('state-config')
        try:
            data = state_config['geometry']['mainwindow']
            geom = base64.b64decode(data, validate=True)
        except KeyError:
            # First start
            self._set_default_geometry()

# 需要导入模块: from PyQt5.QtWidgets import QVBoxLayout [as 别名]
# 或者: from PyQt5.QtWidgets.QVBoxLayout import removeWidget [as 别名]
class CollapsibleFrame(QFrame):

    expanded = pyqtSignal()
    collapsed = pyqtSignal()

    def __init__(self, parent: QWidget = None):
        # Constructs a frame widget with frame style NoFrame and a 1-pixel frame width.
        super(CollapsibleFrame, self).__init__(parent)
        # possible values are:
        #   QFrame.NoFrame, QFrame.Box, QFrame.Panel, QFrame.StyledPanel,
        #   QFrame.HLine, QFrame.VLine, QFrame.WinPanel
        self.setFrameShape(QFrame.StyledPanel)
        # possible values are:  QFrame.Plain, QFrame.Raised, QFrame.Sunken
        self.setFrameShadow(QFrame.Plain)
        # layout
        self._layout = QVBoxLayout()
        self._layout.setContentsMargins(0, 0, 0, 0)
        self._layout.setSpacing(0)
        self.setLayout(self._layout)
        # button
        self._button = QToolButton(self)
        self._button.setArrowType(Qt.RightArrow)
        self._button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self._button.setAutoRaise(False)
        self._button.setText('CollapsibleFrame')
        self._button.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
        self._layout.addWidget(self._button, 0)
        self._button.setVisible(True)
        # group box
        self._panel = QWidget(self)
        self._layout.addWidget(self._panel)
        self._panel.setVisible(False)
        self._panel_layout = QVBoxLayout()
        self._panel_layout.setContentsMargins(1, 1, 1, 1)
        self._panel_layout.setSpacing(2)
        self._panel.setLayout(self._panel_layout)
        # connect signals
        self._button.clicked.connect(self.on_button_click)
        # private state variables
        self._is_collapsed = True

    def setTitle(self, title: str):
        self._button.setText(title)

    def addWidget(self, widget: QWidget):
        self._panel_layout.addWidget(widget)

    def removeWidget(self, widget: QWidget):
        self._panel_layout.removeWidget(widget)

    def is_expanded(self) -> bool:
        return not self._is_collapsed

    def expand(self):
        self._button.setArrowType(Qt.DownArrow)
        self._panel.setVisible(True)
        self._is_collapsed = False
        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)

    def collapse(self):
        self._panel.setVisible(False)
        self._button.setArrowType(Qt.RightArrow)
        self._is_collapsed = True
        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)

    @pyqtSlot()
    def on_button_click(self):
        if self._is_collapsed:
            self.expand()
            self.expanded.emit()
            return
        else:
            self.collapse()
            self.collapsed.emit()
            return