Python QWidget.setVisible方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
    def _close_group(self, main_layout, group_name, group_layout):
        """Closes the the existing group, used during controls creation
        """
        debug_print('FormContainer._close_group close group', group_name)

        # The widget that holds this group's controls
        controls_widget = QWidget()
        controls_widget.setLayout(group_layout)

        if group_name:
            # Group controls start out hidden
            controls_widget.setVisible(False)

            # The group box, which contains the label to toggle the controls
            # and the controls themselves
            group_box_layout = QVBoxLayout()
            group_box_layout.addWidget(ToggleWidgetLabel(
                group_name, controls_widget, initially_visible=False
            ))
            group_box_layout.addWidget(controls_widget)
            group_box_layout.setContentsMargins(
                0,  # left
                0,  # top
                0,  # right
                0   # bottom
            )
            group_box = QGroupBox()
            group_box.setLayout(group_box_layout)

            # Add the group box to the main layout
            main_layout.addRow(group_box)
        else:
            # current group has no name and therefore no toggle group
            main_layout.addRow(controls_widget)

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
 def setVisible(self, val):
     """Override the QWidget::setVisible(bool) method to properly
        recalculate the editor viewport.
     """
     if val != self.isVisible():
         if val:
             QWidget.setVisible(self, True)
         else:
             QWidget.setVisible(self, False)
         self._qpart.updateViewport()

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
class MusicPreviewWidget(QWidget):
    def __init__(self, parent=None):
        super(MusicPreviewWidget, self).__init__(parent)
        self._lastbuildtime = 10.0
        self._running = None
        self._current = None

        self._chooserLabel = QLabel()
        self._chooser = QComboBox(self, activated=self.selectDocument)
        self._log = log.Log()
        self._view = popplerview.View()
        self._progress = widgets.progressbar.TimedProgressBar()

        self._stack = QStackedLayout()
        self._top = QWidget()

        layout = QVBoxLayout()
        self.setLayout(layout)

        layout.addWidget(self._top)
        layout.addLayout(self._stack)
        layout.addWidget(self._progress)

        top = QHBoxLayout()
        top.setContentsMargins(0, 0, 0, 0)
        top.setSpacing(2)
        self._top.setLayout(top)
        top.addWidget(self._chooserLabel)
        top.addWidget(self._chooser)
        top.addStretch(1)

        self._stack.addWidget(self._log)
        self._stack.addWidget(self._view)

        self._top.hide()
        app.aboutToQuit.connect(self.cleanup)
        app.translateUI(self)

    def translateUI(self):
        self._chooserLabel.setText(_("Document:"))

    def preview(self, text, title=None):
        """Runs LilyPond on the given text and shows the resulting PDF."""
        j = self._running = MusicPreviewJob(text, title)
        j.done.connect(self._done)
        self._log.clear()
        self._log.connectJob(j)
        j.start()
        self._progress.start(self._lastbuildtime)

    def _done(self, success):
        self._progress.stop(False)
        pdfs = self._running.resultfiles()
        self.setDocuments(pdfs)
        if not pdfs:
            self._stack.setCurrentWidget(self._log)
            return
        self._lastbuildtime = self._running.elapsed_time()
        self._stack.setCurrentWidget(self._view)
        if self._current:
            self._current.cleanup()
        self._current = self._running # keep the tempdir
        self._running = None

    def setDocuments(self, pdfs):
        """Loads the given PDF path names in the UI."""
        self._documents = [popplertools.Document(name) for name in pdfs]
        self._chooser.clear()
        self._chooser.addItems([d.name() for d in self._documents])
        self._top.setVisible(len(self._documents) > 1)
        if pdfs:
            self._chooser.setCurrentIndex(0)
            self.selectDocument(0)
        else:
            self._view.clear()

    def selectDocument(self, index):
        doc = self._documents[index].document()
        if doc:
            self._view.load(doc)

    def cleanup(self):
        if self._running:
            self._running.abort()
            self._running.cleanup()
            self._running = None
        if self._current:
            self._current.cleanup()
            self._current = None
        self._stack.setCurrentWidget(self._log)
        self._top.hide()
        self._view.clear()

    def print_(self):
        """Prints the currently displayed document."""
        if self._documents:
            doc = self._documents[self._chooser.currentIndex()]
            import popplerprint
            popplerprint.printDocument(doc, self)

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
    def __evt_yeahdoc_contextMenu(self, p):
        """
        context menu
        """
        item = self.yeahdoclisttree.currentItem()
        if item == None or item.isDisabled():
            pass
        else:
            menu = QMenu()

            # menu top
            action = QWidgetAction(self)
            title = item.text(0)
            if len(title) < 25:
                for i in range(len(title), 25):
                    title = title + "  &nbsp;"
            action.setDefaultWidget(
                QLabel("&nbsp;&nbsp;<img  src='%s'/>  &nbsp;%s" % (getPath("iconDir", "yeahdoc/item.png"), title)))
            menu.addAction(action)

            menu.addSeparator()

            menu.addAction(self.__actions["__yeahdoc_open__"])
            menu.addAction(self.__actions["__yeahdoc_edit__"])

            # change class
            change_class_menu = QMenu()
            entry = YeahdocDatasSupply().bb_read1_simple(item.getMark())
            current_categoryid = entry['categoryid']
            for class_item in YeahdocDatasSupply().bc_list():
                action = QAction(class_item["title"], self, \
                                 triggered=lambda re, item=item, categoryid=str(class_item["id"]): \
                                     self.__evt_change_category(categoryid, item))
                action.setIcon(QIcon(getPath("iconDir", "yeahdoc/flag/%s" % str(class_item["img"]))))
                action.setIconVisibleInMenu(True)
                # mark current class id menu checked
                if class_item['id'] == current_categoryid:
                    action.setCheckable(True)
                    action.setChecked(True)
                    action.setDisabled(True)
                change_class_menu.addAction(action)

            action = QAction(QIcon(getPath("iconDir", "yeahdoc/change.png")),
                             QApplication.translate("YeahdocList", "Change Category"), self)
            action.setIconVisibleInMenu(True)
            action.setMenu(change_class_menu)

            menu.addAction(action)

            menu.addAction(self.__actions["__yeahdoc_star__"])
            menu.addAction(self.__actions["__yeahdoc_rename__"])
            menu.addAction(self.__actions["__yeahdoc_delete__"])

            menu.addSeparator()

            setmode = True if entry['lock'] == 0 else False
            action = QWidgetAction(self)
            widget = QWidget()
            layout = QHBoxLayout()
            layout.setSpacing(0)
            layout.setMargin(0)
            widget.setLayout(layout)
            widgetMore = QWidget()
            widgetMore.setVisible(False)
            layoutMore = QHBoxLayout()
            layoutMore.setSpacing(0)
            layoutMore.setMargin(0)
            widgetMore.setLayout(layoutMore)

            layout.addWidget(QLabel("<img src='%s'/>" % getPath("iconDir", "yeahdoc/password.png")))
            passwordMore = QPushButton(
                QApplication.translate("YeahdocEditor", "Encrypt") if setmode else QApplication.translate(
                    "YeahdocEditor", "Decrypt"))
            passwordMore.setFlat(True)
            layout.addWidget(passwordMore)

            passwordInput = QLineEdit()
            passwordInput.setEchoMode(QLineEdit.Password)
            passwordInput.setMaximumWidth(70)

            layoutMore.addWidget(passwordInput)

            if setmode:
                passwordInputAgain = QLineEdit()
                passwordInputAgain.setEchoMode(QLineEdit.Password)
                passwordInputAgain.setMaximumWidth(70)
                layoutMore.addWidget(QLabel(QApplication.translate("YeahdocEditor", "Re")))
                layoutMore.addWidget(passwordInputAgain)

            passwordSubmit = QPushButton("OK")
            passwordSubmit.setFlat(True)
            layoutMore.addWidget(passwordSubmit)

            layout.addWidget(widgetMore)
            layout.addItem(QSpacerItem(0, 20, QSizePolicy.Expanding, QSizePolicy.Expanding))

            action.setDefaultWidget(widget)
            QObject.connect(passwordSubmit, SIGNAL("clicked ()"),
                            lambda: self.__evt_password(setmode, passwordInput.text(),
                                                        passwordInputAgain.text() if setmode else ""))
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
class MainWindow(Ui_MainWindow):
    def __init__(self, parent, out_pipe, dark=False):
        self.parent = parent
        if dark:
            self.console = ConsoleWidget(out_pipe,
                                         QColor(220, 220, 220),
                                         QColor(255, 220, 50),
                                         QColor(255, 50, 50))
        else:
            self.console = ConsoleWidget(out_pipe,
                                         QColor(0, 0, 0),
                                         QColor(255, 220, 30),
                                         QColor(255, 0, 0))

        self.scene = SceneDescription()
        self.scene_view = SceneViewWidget(self.parent, self, self.scene)
        self.render_view_widget = QWidget()
        self.render_view = RenderViewWidget(self.render_view_widget)

    def initialize(self):
        self.gridLayout.addWidget(self.scene_view)
        self.gridLayout.addWidget(self.render_view_widget, 0, 1)

        self.render_view.setupUi(self.render_view_widget)

        self.console.setupUi(self.console_dock_contents)
        self.console.initialize()

        self.action_console.triggered.connect(self.toggle_log)
        self.action_render_view.triggered.connect(self.toggle_render_view)
        self.action_scene_view.triggered.connect(self.toggle_scene_view)
        self.action_toggle_fullscreen.triggered.connect(self.toggle_fullscreen)
        self.action_quit.triggered.connect(self.close)

        self.action_obj.triggered.connect(self.import_obj)

        self.centralwidget.addAction(self.action_console)
        self.centralwidget.addAction(self.action_render_view)
        self.centralwidget.addAction(self.action_scene_view)
        self.centralwidget.addAction(self.action_toggle_fullscreen)
        self.centralwidget.addAction(self.action_quit)
        self.centralwidget.addAction(self.action_obj)

        self.action_render_view.setChecked(False)
        self.toggle_render_view()

    def toggle_log(self):
        self.console_dock.setVisible(self.action_console.isChecked())

    def toggle_render_view(self):
        self.render_view_widget.setVisible(self.action_render_view.isChecked())
        pass

    def toggle_scene_view(self):
        self.scene_view.setVisible(self.action_scene_view.isChecked())

    def toggle_fullscreen(self):
        if self.action_toggle_fullscreen.isChecked():
            self.parent.showFullScreen()
            self.parent.menuBar().hide()
        else:
            self.parent.showNormal()
            self.parent.menuBar().show()

    def import_obj(self):
        filename, _ = QFileDialog.getOpenFileName(self.parent, 'Import .obj', r'w:\Renderer\obj', '.obj (*.obj)')
        if not filename:
            return

        print('Loading...  {0}'.format(filename))
        self.scene.import_mesh(filename)
        self.scene_view.update_list()
        self.scene_view.refresh()

    def load_png(self, filename):
        self.action_scene_view.setChecked(False)
        self.toggle_scene_view()
        self.render_view.show(filename)

    def close(self):
        self.parent.close()

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [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

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
class HeapPluginForm(PluginForm):
    def __init__(self):
        super(HeapPluginForm, self).__init__()
        self.parent      = None
        self.config_path = None
        self.config      = None
        self.tracer      = None
        self.heap        = None
        self.cur_arena   = None # default: main_arena
        self.ptr_size    = get_arch_ptrsize()

    def OnCreate(self, form):
        self.parent = self.FormToPyQtWidget(form)     
        self.setup_gui()
        self.init_heap()
        self.populate_gui()

    def setup_gui(self):
        self.chunk_widget = ChunkWidget(self)
        self.tracer_tab = TracerWidget(self)
        self.arena_widget = ArenaWidget(self)
        self.bins_widget = BinsWidget(self)
        self.tcache_widget = TcacheWidget(self)
        self.magic_widget = MagicWidget(self)
        self.config_widget = ConfigWidget(self)

        self.tabs = QTabWidget()
        self.tabs.addTab(self.tracer_tab, "Tracer")
        self.tabs.addTab(self.arena_widget, "Arena")
        self.tabs.addTab(self.bins_widget, "Bins")
        self.tabs.addTab(self.tcache_widget, "Tcache")
        self.tabs.addTab(self.magic_widget, "Magic")
        self.tabs.addTab(self.config_widget, "Config")

        self.btn_reload = QPushButton("Reload info")
        icon = QtGui.QIcon(os.path.normpath(ICONS_DIR + '/refresh.png'))
        self.btn_reload.setIcon(icon)
        self.btn_reload.setFixedWidth(120)
        self.btn_reload.setEnabled(False)
        self.btn_reload.clicked.connect(self.reload_gui_info)

        self.cb_arenas = QComboBox()
        self.cb_arenas.setFixedWidth(150)
        self.cb_arenas.currentIndexChanged[int].connect(self.cb_arenas_changed)

        hbox_arenas = QHBoxLayout()        
        hbox_arenas.addWidget(QLabel('Switch arena: '))
        hbox_arenas.addWidget(self.cb_arenas)
        hbox_arenas.setContentsMargins(0, 0, 0, 0)

        self.arenas_widget = QWidget()
        self.arenas_widget.setLayout(hbox_arenas)
        self.arenas_widget.setVisible(False)

        self.txt_warning = QLabel()
        self.txt_warning.setStyleSheet("font-weight: bold; color: red")
        self.txt_warning.setVisible(False)

        hbox_top = QHBoxLayout()
        hbox_top.addWidget(self.btn_reload)
        hbox_top.addWidget(self.arenas_widget)
        hbox_top.addWidget(self.txt_warning)
        hbox_top.setContentsMargins(0, 0, 0, 0)
        hbox_top.addStretch(1)

        vbox_left_panel = QVBoxLayout()        
        vbox_left_panel.addLayout(hbox_top)
        vbox_left_panel.addWidget(self.tabs)
        vbox_left_panel.setContentsMargins(0, 0, 0, 0)

        left_panel = QWidget()
        left_panel.setLayout(vbox_left_panel)

        self.splitter = QSplitter(QtCore.Qt.Horizontal)
        self.splitter.addWidget(left_panel)
        self.splitter.addWidget(self.chunk_widget)
        self.splitter.setStretchFactor(0, 1)

        main_layout = QVBoxLayout()
        main_layout.addWidget(self.splitter)
        self.parent.setLayout(main_layout)

    def populate_gui(self):
        self.magic_widget.populate_libc_offsets()
        self.reload_gui_info()

    def reload_gui_info(self, from_arena_cb=False):
        if not self.heap:
            return

        if not self.heap.get_heap_base():
            self.show_warning('Heap not initialized')
            return

        self.hide_warning()
        self.arenas_widget.setVisible(True)

        if not from_arena_cb:
            self.populate_arenas()

#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
            if not self.question(msg):
                if self.question(_("Do you want to delete '{}'?").format(path)):
                    os.remove(path)
                    self.show_warning(_('The file was removed'))
                return
            self.show()
            self.data = storage.db.data # FIXME
            self.run(action)
            for k, v in self.data.items():
                storage.put(k, v)
            storage.write()
            return

        if storage.requires_upgrade():
            self.upgrade_storage(storage)

    def finished(self):
        """Called in hardware client wrapper, in order to close popups."""
        return

    def on_error(self, exc_info):
        if not isinstance(exc_info[1], UserCancelled):
            self.logger.error("on_error", exc_info=exc_info)
            self.show_error(str(exc_info[1]))

    def set_icon(self, filename):
        prior_filename, self.icon_filename = self.icon_filename, filename
        self.logo.setPixmap(QPixmap(icon_path(filename))
                            .scaledToWidth(60, mode=Qt.SmoothTransformation))
        return prior_filename

    def set_layout(self, layout, title=None, next_enabled=True):
        self.title.setText("<b>%s</b>"%title if title else "")
        self.title.setVisible(bool(title))
        # Get rid of any prior layout by assigning it to a temporary widget
        prior_layout = self.main_widget.layout()
        if prior_layout:
            QWidget().setLayout(prior_layout)
        self.main_widget.setLayout(layout)
        self.back_button.setEnabled(True)
        self.next_button.setEnabled(next_enabled)
        if next_enabled:
            self.next_button.setFocus()
        self.main_widget.setVisible(True)
        self.please_wait.setVisible(False)

    def exec_layout(self, layout, title=None, raise_on_cancel=True,
                        next_enabled=True):
        self.set_layout(layout, title, next_enabled)
        result = self.loop.exec_()
        if not result and raise_on_cancel:
            raise UserCancelled
        if result == 1:
            raise GoBack from None
        self.title.setVisible(False)
        self.back_button.setEnabled(False)
        self.next_button.setEnabled(False)
        self.main_widget.setVisible(False)
        self.please_wait.setVisible(True)
        self.refresh_gui()
        return result

    def refresh_gui(self):
        # For some reason, to refresh the GUI this needs to be called twice
        self.app.processEvents()
        self.app.processEvents()

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

    """Find In Files central widget in tools dock."""

    def __init__(self, parent):
        super(FindInFilesWidget, self).__init__(parent)
        self._main_container = IDE.get_service('main_container')
        self._explorer_container = IDE.get_service('explorer')
        self._result_widget = FindInFilesResult()
        self._open_find_button = QPushButton(translations.TR_FIND + "!")
        self._stop_button = QPushButton(translations.TR_STOP + "!")
        self._clear_button = QPushButton(translations.TR_CLEAR + "!")
        self._replace_button = QPushButton(translations.TR_REPLACE)
        self._find_widget = FindInFilesDialog(self._result_widget, self)
        self._error_label = QLabel(translations.TR_NO_RESULTS)
        self._error_label.setVisible(False)
        #Replace Area
        self.replace_widget = QWidget()
        hbox_replace = QHBoxLayout(self.replace_widget)
        hbox_replace.setContentsMargins(0, 0, 0, 0)
        self.lbl_replace = QLabel(translations.TR_REPLACE_RESULTS_WITH)
        self.lbl_replace.setTextFormat(Qt.PlainText)
        self.replace_edit = QLineEdit()
        hbox_replace.addWidget(self.lbl_replace)
        hbox_replace.addWidget(self.replace_edit)
        self.replace_widget.setVisible(False)
        #Main Layout
        main_hbox = QHBoxLayout(self)
        #Result Layout
        tree_vbox = QVBoxLayout()
        tree_vbox.addWidget(self._result_widget)
        tree_vbox.addWidget(self._error_label)
        tree_vbox.addWidget(self.replace_widget)

        main_hbox.addLayout(tree_vbox)
        #Buttons Layout
        vbox = QVBoxLayout()
        vbox.addWidget(self._open_find_button)
        vbox.addWidget(self._stop_button)
        vbox.addWidget(self._clear_button)
        vbox.addSpacerItem(QSpacerItem(0, 50,
            QSizePolicy.Fixed, QSizePolicy.Expanding))
        vbox.addWidget(self._replace_button)
        main_hbox.addLayout(vbox)

        self._open_find_button.setFocus()
        #signals
        self._open_find_button.clicked['bool'].connect(self.open)
        self._stop_button.clicked['bool'].connect(self._find_stop)
        self._clear_button.clicked['bool'].connect(self._clear_results)
        self._result_widget.itemActivated['QTreeWidgetItem*', int].connect(self._go_to)
        self._result_widget.itemClicked['QTreeWidgetItem*', int].connect(self._go_to)
        self._find_widget.finished.connect(self._find_finished)
        self._find_widget.findStarted.connect(self._find_started)
        self._replace_button.clicked['bool'].connect(self._replace_results)

    def _find_finished(self):
        """Search has finished."""
        self._stop_button.setEnabled(False)
        self._open_find_button.setEnabled(True)
        self._error_label.setVisible(False)
        if not self._result_widget.topLevelItemCount():
            self._error_label.setVisible(True)
        if self._find_widget.check_replace.isChecked():
            self.replace_widget.setVisible(True)
            self._replace_button.setEnabled(True)
            self.replace_edit.setText(self._find_widget.replace_line.text())
        else:
            self._replace_button.setEnabled(False)
            self.replace_widget.setVisible(False)
        self._result_widget.setFocus()

    def _find_stop(self):
        """Stop search."""
        self._find_widget._kill_thread()

    def _find_started(self):
        """Search has started."""
        self._open_find_button.setEnabled(False)
        self._stop_button.setEnabled(True)

    def _clear_results(self):
        """Clear the results displayed."""
        self._result_widget.clear()

    def _go_to(self, item, val):
        """Open the proper file in the proper line from the results."""
        if item.text(1):
            parent = item.parent()
            file_name = parent.text(0)
            lineno = item.text(1)
            root_dir_name = parent.dir_name_root
            file_path = file_manager.create_path(root_dir_name, file_name)
            #open the file and jump_to_line
            self._main_container.open_file(file_path, line=int(lineno) - 1)
            self._main_container.get_current_editor().setFocus()

    def open(self):
        """Open the selected file in the proper line."""
        if not self._find_widget.isVisible():
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
    def request_trezor_init_settings(self, wizard, method, device_id):
        vbox = QVBoxLayout()
        next_enabled = True

        devmgr = self.device_manager()
        client = devmgr.client_by_id(device_id)
        if not client:
            raise Exception(_("The device was disconnected."))
        model = client.get_trezor_model()
        fw_version = client.client.version

        # label
        label = QLabel(_("Enter a label to name your device:"))
        name = QLineEdit()
        hl = QHBoxLayout()
        hl.addWidget(label)
        hl.addWidget(name)
        hl.addStretch(1)
        vbox.addLayout(hl)

        # word count
        gb = QGroupBox()
        hbox1 = QHBoxLayout()
        gb.setLayout(hbox1)
        vbox.addWidget(gb)
        gb.setTitle(_("Select your seed length:"))
        bg_numwords = QButtonGroup()
        word_counts = (12, 18, 24)
        for i, count in enumerate(word_counts):
            rb = QRadioButton(gb)
            rb.setText(_("{:d} words").format(count))
            bg_numwords.addButton(rb)
            bg_numwords.setId(rb, i)
            hbox1.addWidget(rb)
            rb.setChecked(True)

        # PIN
        cb_pin = QCheckBox(_('Enable PIN protection'))
        cb_pin.setChecked(True)
        vbox.addWidget(WWLabel(RECOMMEND_PIN))
        vbox.addWidget(cb_pin)

        # "expert settings" button
        expert_vbox = QVBoxLayout()
        expert_widget = QWidget()
        expert_widget.setLayout(expert_vbox)
        expert_widget.setVisible(False)
        expert_button = QPushButton(_("Show expert settings"))
        def show_expert_settings():
            expert_button.setVisible(False)
            expert_widget.setVisible(True)
        expert_button.clicked.connect(show_expert_settings)
        vbox.addWidget(expert_button)

        # passphrase
        passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
        passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
        passphrase_warning.setStyleSheet("color: red")
        cb_phrase = QCheckBox(_('Enable passphrases'))
        cb_phrase.setChecked(False)
        expert_vbox.addWidget(passphrase_msg)
        expert_vbox.addWidget(passphrase_warning)
        expert_vbox.addWidget(cb_phrase)

        # ask for recovery type (random word order OR matrix)
        bg_rectype = None
        if method == TIM_RECOVER and not model == 'T':
            gb_rectype = QGroupBox()
            hbox_rectype = QHBoxLayout()
            gb_rectype.setLayout(hbox_rectype)
            expert_vbox.addWidget(gb_rectype)
            gb_rectype.setTitle(_("Select recovery type:"))
            bg_rectype = QButtonGroup()

            rb1 = QRadioButton(gb_rectype)
            rb1.setText(_('Scrambled words'))
            bg_rectype.addButton(rb1)
            bg_rectype.setId(rb1, RECOVERY_TYPE_SCRAMBLED_WORDS)
            hbox_rectype.addWidget(rb1)
            rb1.setChecked(True)

            rb2 = QRadioButton(gb_rectype)
            rb2.setText(_('Matrix'))
            bg_rectype.addButton(rb2)
            bg_rectype.setId(rb2, RECOVERY_TYPE_MATRIX)
            hbox_rectype.addWidget(rb2)

        # no backup
        cb_no_backup = None
        if method == TIM_NEW:
            cb_no_backup = QCheckBox(f'''{_('Enable seedless mode')}''')
            cb_no_backup.setChecked(False)
            if (model == '1' and fw_version >= (1, 7, 1)
                    or model == 'T' and fw_version >= (2, 0, 9)):
                cb_no_backup.setToolTip(SEEDLESS_MODE_WARNING)
            else:
                cb_no_backup.setEnabled(False)
                cb_no_backup.setToolTip(_('Firmware version too old.'))
            expert_vbox.addWidget(cb_no_backup)

#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
class LedgerAuthDialog(QDialog):
    def __init__(self, handler, data):
        '''Ask user for 2nd factor authentication. Support text, security card and paired mobile methods.
        Use last method from settings, but support new pairing and downgrade.
        '''
        QDialog.__init__(self, handler.top_level_window())
        self.handler = handler
        self.txdata = data
        self.idxs = self.txdata['keycardData'] if self.txdata['confirmationType'] > 1 else ''
        self.setMinimumWidth(650)
        self.setWindowTitle(_("Ledger Wallet Authentication"))
        self.cfg = copy.deepcopy(self.handler.win.wallet.get_keystore().cfg)
        self.dongle = self.handler.win.wallet.get_keystore().get_client().dongle
        self.ws = None
        self.pin = ''
        
        self.devmode = self.getDevice2FAMode()
        if self.devmode == 0x11 or self.txdata['confirmationType'] == 1:
            self.cfg['mode'] = 0
        
        vbox = QVBoxLayout()
        self.setLayout(vbox)
        
        def on_change_mode(idx):
            if idx < 2 and self.ws:
                self.ws.stop()
                self.ws = None
            self.cfg['mode'] = 0 if self.devmode == 0x11 else idx if idx > 0 else 1
            if self.cfg['mode'] > 1 and self.cfg['pair'] and not self.ws:
                self.req_validation()
            if self.cfg['mode'] > 0:
                self.handler.win.wallet.get_keystore().cfg = self.cfg
                self.handler.win.wallet.save_keystore()
            self.update_dlg()
        def add_pairing():
            self.do_pairing()
        def return_pin():
            self.pin = self.pintxt.text() if self.txdata['confirmationType'] == 1 else self.cardtxt.text() 
            if self.cfg['mode'] == 1:
                self.pin = ''.join(chr(int(str(i),16)) for i in self.pin)
            self.accept()
        
        self.modebox = QWidget()
        modelayout = QHBoxLayout()
        self.modebox.setLayout(modelayout)
        modelayout.addWidget(QLabel(_("Method:")))
        self.modes = QComboBox()
        modelayout.addWidget(self.modes, 2)
        self.addPair = QPushButton(_("Pair"))
        self.addPair.setMaximumWidth(60)
        modelayout.addWidget(self.addPair)
        modelayout.addStretch(1)
        self.modebox.setMaximumHeight(50)
        vbox.addWidget(self.modebox)
        
        self.populate_modes()
        self.modes.currentIndexChanged.connect(on_change_mode)
        self.addPair.clicked.connect(add_pairing)
        
        self.helpmsg = QTextEdit()
        self.helpmsg.setStyleSheet("QTextEdit { background-color: lightgray; }")
        self.helpmsg.setReadOnly(True)
        vbox.addWidget(self.helpmsg)
        
        self.pinbox = QWidget()
        pinlayout = QHBoxLayout()
        self.pinbox.setLayout(pinlayout)
        self.pintxt = QLineEdit()
        self.pintxt.setEchoMode(2)
        self.pintxt.setMaxLength(4)
        self.pintxt.returnPressed.connect(return_pin)
        pinlayout.addWidget(QLabel(_("Enter PIN:")))
        pinlayout.addWidget(self.pintxt)
        pinlayout.addWidget(QLabel(_("NOT DEVICE PIN - see above")))
        pinlayout.addStretch(1)
        self.pinbox.setVisible(self.cfg['mode'] == 0)
        vbox.addWidget(self.pinbox)
                    
        self.cardbox = QWidget()
        card = QVBoxLayout()
        self.cardbox.setLayout(card)
        self.addrtext = QTextEdit()
        self.addrtext.setStyleSheet("QTextEdit { color:blue; background-color:lightgray; padding:15px 10px; border:none; font-size:20pt; font-family:monospace; }")
        self.addrtext.setReadOnly(True)
        self.addrtext.setMaximumHeight(130)
        card.addWidget(self.addrtext)
        
        def pin_changed(s):
            if len(s) < len(self.idxs):
                i = self.idxs[len(s)]
                addr = self.txdata['address']
                if not constants.net.TESTNET:
                    text = addr[:i] + '<u><b>' + addr[i:i+1] + '</u></b>' + addr[i+1:]
                else:
                    # pin needs to be created from mainnet address
                    addr_mainnet = bitcoin.script_to_address(bitcoin.address_to_script(addr), net=constants.BitcoinMainnet)
                    addr_mainnet = addr_mainnet[:i] + '<u><b>' + addr_mainnet[i:i+1] + '</u></b>' + addr_mainnet[i+1:]
                    text = str(addr) + '\n' + str(addr_mainnet)
                self.addrtext.setHtml(str(text))
            else:
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
 def setVisible(self, val):
     if self._completer.frame:
         self._completer.frame.setVisible(False)
         self._completer.setText('')
     QWidget.setVisible(self, val)

# 需要导入模块: from PyQt5.QtWidgets import QWidget [as 别名]
# 或者: from PyQt5.QtWidgets.QWidget import setVisible [as 别名]
 def setVisible(self, value):
     """Show/Hide the widget"""
     QWidget.setVisible(self, value)
     self._neditor.side_widgets.update_viewport()

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

#.........这里部分代码省略.........
            if line != "":
                # print("1: %s" % line)
                self.consoletextedit.append(line)
        self.consoletextedit.ensureCursorVisible()
        # autoscroll to last line's first character
        self.consoletextedit.moveCursor(QTextCursor.End)
        self.consoletextedit.moveCursor(QTextCursor.StartOfLine)

    @pyqtSlot(QProcess.ProcessState)
    def _process_stateChanged(self, state):
        """ procress_stateChanged """
        # TODO handle procress_stateChanged
        print("procress_stateChanged: %s" % state)

    def center(self):
        """Center Window on the Current Screen,with Multi-Monitor support."""
        window_geometry = self.frameGeometry()
        mousepointer_position = QApplication.desktop().cursor().pos()
        screen = QApplication.desktop().screenNumber(mousepointer_position)
        centerpoint = QApplication.desktop().screenGeometry(screen).center()
        window_geometry.moveCenter(centerpoint)
        self.move(window_geometry.topLeft())

    def move_to_mouse_position(self):
        """Center the Window on the Current Mouse position."""
        window_geometry = self.frameGeometry()
        window_geometry.moveCenter(QApplication.desktop().cursor().pos())
        self.move(window_geometry.topLeft())

    def show_console(self):
        """Show syncthing console"""
        visible = not self.consolewidget.isVisible
        print("bVisible: %s" % visible)
        self.consolewidget.setVisible(True)
        self.consolewidget.resize(QSize(200, 100))

    def view_source(self):
        """ TODO: Call methods to load and display source code."""
        # call(('xdg-open ' if sys.platform.startswith("linux") else 'open ')
        #      + __file__, shell=True)
        pass

    def view_syncthing_source(self):
        """Call methods to load and display web page source code."""
        print("view_syncthing_source start")
        # access_manager = self.view.page().networkAccessManager()
        # reply = access_manager.get(QNetworkRequest(self.view.url()))
        # reply.finished.connect(self.slot_source_downloaded)

    def slot_source_downloaded(self):
        """Show actual page source code."""
        reply = self.sender()
        # TODO: highlight html source editor/viewer
        self.textedit = QPlainTextEdit()
        self.textedit.setAttribute(Qt.WA_DeleteOnClose)
        self.textedit.setReadOnly(True)
        self.textedit.setPlainText(QTextStream(reply).readAll())
        self.textedit.show()
        reply.deleteLater()

    @pyqtSlot()
    def start_loading(self):
        """show progressbar when downloading data"""
        self.progressbar.show()

    @pyqtSlot(bool)